Newsletter
Subscribe to our Flutter newsletter!
By submitting your email you agree to receive the content requested and to LeanCode's Privacy Policy

App Migration Strategies for Flutter: Rewrite, Add-to-App or Hybrid

Wojciech Zielonka
Wojciech Zielonka - Performance Marketing Manager at LeanCode
May 4, 2026 • 16 min.
Wojciech Zielonka
Wojciech Zielonka
Performance Marketing Manager at LeanCode

Edit: Article fully updated in November 2026

There are three ways to migrate a native iOS and Android app to Flutter: rebuild it from scratch in one big-bang rewrite, add Flutter to the existing app and move it screen by screen (add-to-app), or combine the two in a hybrid approach. The right choice depends on the size and state of your native code, how much risk your business can take and whether your app has to keep shipping during the migration.

The mobile app migration strategy you select will influence every aspect of the process: how technical debt is managed, how the product architecture evolves and how quickly you can deliver value. This is not solely a technical decision – it must also account for business objectives and risks. Business and technical leaders need to agree on the approach together, as the choice affects every stakeholder.

We'll walk you through three proven ways to move from Swift and Kotlin to Flutter:

  • From scratch (big-bang rewrite): building a new Flutter app from the ground up and replacing the native apps in one release.
  • Add-to-app: adding Flutter to your existing native app and migrating it screen by screen while the app keeps shipping.
  • Hybrid approach: building add-to-app modules that later become part of a new standalone Flutter app.

There's no one-size-fits-all solution. The aim here is to give you the clarity you need to make a well-informed decision that minimizes risk and sets your Flutter migration up for long-term success. If you need the short version, jump to the summary table.

App migration strategy 1: From scratch (big-bang rewrite)

Sometimes, the fastest way forward is to start over. A full rebuild in Flutter – often called a “big bang” rewrite – means replacing your existing iOS and Android apps entirely with a new, unified Flutter codebase. While it's a bold move, this strategy can be a powerful opportunity for organizations facing specific challenges.

Why?

The from-scratch approach offers:

  • A clean slate when it comes to removing accumulated technical debt.
  • The opportunity to implement modern architectural principles.
  • A unified, cross-platform codebase.

It's a strong fit for situations with external triggers, such as launching a new design system, undertaking rebranding initiatives or meeting new accessibility requirements.

Why not?

A big-bang rewrite:

  • Is a high-risk, high-reward strategy.
  • Requires significant upfront investment.
  • Requires you to recover all the business logic, edge cases and integrations hidden in the old code before the first release.
  • Means maintaining the native apps in parallel until the new app launches, because the release is all or nothing.
  • Carries potential for delays and budget overruns.
  • May impact user experience during the transition period.
  • Risks losing market share if the new app arrives late or fails to match the old one.

When to use this approach

A big-bang rewrite isn't for every project, but in certain scenarios it can deliver exceptional value. The following examples show when starting from scratch in Flutter can be the most effective path forward.

Legacy app migration

If your application is weighed down by a legacy codebase, rewriting it in Flutter can provide a fresh start. Legacy systems often accumulate technical debt – outdated libraries, inefficient algorithms and tangled architectures – that becomes costly and time-consuming to fix incrementally. Piecemeal changes usually address symptoms rather than root causes.

Starting from scratch with Flutter enables modern development practices, clean architecture and a unified codebase across iOS (Swift/Objective-C) and Android (Java/Kotlin). This not only eliminates fragmentation and reduces maintenance overhead but also creates an opportunity to tackle technical debt across the broader tech stack, from backend systems to web frontends.

The state of the code matters as much as its age. If your native code is undocumented and nobody on the team fully understands it anymore, add-to-app makes you pay twice: once to understand the old code and again to build and maintain the boundary between it and Flutter. In that case, a rewrite is often the cleaner path.

Small apps and unmaintained code

A rewrite also wins when the app is small enough to rebuild in a few months. The extra complexity of running native code and Flutter side by side is then hard to justify. The same goes for an app nobody maintains anymore: it's easier to rebuild it than to revive it only to embed Flutter in it. We compare both paths in more detail in our guide to Flutter add-to-app vs a full rewrite.

New design system

When your organization requires a new design system – especially across multiple apps or platforms – a full rewrite in Flutter can be an ideal solution. Legacy apps often rely on ad-hoc development (“UI spaghetti” due to legacy code, multiple technologies or rushed initial builds) that makes cross-platform consistency nearly impossible.

Rebuilding with Flutter allows you to start fresh with standardized, reusable components, ensuring visual and interaction consistency.

On top of that, Flutter provides widgets that can mimic the native platform look and feel from a single codebase, with ready-to-use Material Design and Cupertino libraries. This gives you a scalable foundation for a modern design system without the integration headaches of forcing new components into rigid, outdated structures.

Rebranding initiatives

A rebrand can be an ideal trigger for a Flutter migration. Such efforts often bring the budget and organizational momentum needed to refresh mobile and web frontends, making them a natural catalyst for change.

Older app architectures are often rigid and difficult to adapt to modern design trends or evolving user experience expectations. Flutter, as a flexible and modern framework, enables highly customizable and visually appealing interfaces. A fresh start lets you implement the new brand identity (colors, typography, icons and components) without being limited by legacy code or outdated libraries.

Rebrands also often signal broader shifts: new product positioning, feature sets or even technology stacks. When consistency across all touchpoints is critical (mobile, web, tablets), Flutter's single codebase offers a clear advantage over maintaining separate implementations in multiple languages (Swift/Objective-C/Kotlin/JavaScript), which can interpret brand guidelines inconsistently.

Mergers & Acquisitions (M&A)

M&A scenarios often demand rapid integration of technologies and teams. Rebuilding from scratch in Flutter provides a rare clean-slate opportunity, accelerating consolidation through a unified cross-platform codebase. This not only reduces time-to-market for new features – a critical advantage in competitive industries – but also simplifies long-term maintenance.

Acquired codebases are often outdated or misaligned with new business strategies. While a full rewrite carries risk, the long-term benefits of efficiency, scalability and architectural consistency can far outweigh the challenges of trying to patch together disparate legacy systems.

Accessibility requirements implementation

Accessibility is a growing priority, yet legacy apps often struggle to meet modern standards. Maintaining compliance across separate iOS and Android codebases (each with its own guidelines like VoiceOver or TalkBack) can be inconsistent, complex and costly.

With regulations such as the European Accessibility Act (EAA) mandating accessible digital services, non-compliance risks significant fines and reputational damage. Conducting accessibility audits (e.g., WCAG AA) for two native apps doubles the effort, and fixes on one platform don't necessarily solve issues on the other.

Rebuilding from scratch with Flutter streamlines compliance by consolidating efforts into a single codebase. Audits become more efficient, costs drop and the framework's flexibility makes it easier to adapt to evolving standards. This modern foundation also avoids the limitations of older frameworks that often lack robust accessibility support.

Learn how to migrate your app to Flutter
Migration to Flutter ebook mockup

App migration strategy 2: Add-to-app (screen-by-screen migration)

While a full rebuild offers a clean slate, it's not the only path forward. Flutter add-to-app is Flutter's official way to integrate Flutter into an existing native iOS or Android app. Instead of replacing the app, you add Flutter as a module, move selected screens to it and migrate the rest screen by screen, while the native app keeps running and new features keep landing. For your users, nothing changes: it's the same app with the same store listing, and a Flutter screen looks and behaves like any other screen.

How add-to-app works in practice

Your existing app stays in charge at the start: it opens the same way and keeps its main navigation. Your team adds Flutter to it as a module and builds new or rebuilt screens in Flutter, one at a time. Users move between old and new screens without noticing the difference.

Every place where the existing app and Flutter connect – moving between screens, sharing data, using phone features such as the camera – needs extra integration work. That's where most of the effort and cost sit, so a good migration keeps those connection points as few as possible at every stage. Your developers will find step-by-step guides on how to add Flutter to an existing Android app and how to add Flutter to an existing iOS app.

Every Flutter screen goes live behind a feature flag – a switch your team controls remotely. You can show the new screen to a small share of users first, compare its results with the old one and switch users back if something goes wrong. Flags also mean an unfinished migration never holds up a release: new screens can already be in the app while users still see the old ones.


Why?

The add-to-app approach offers:

  • A way to try Flutter in production, on a real screen with real data and integrations, without full commitment.
  • An app that keeps shipping new features while screens move to Flutter.
  • New features written once for iOS and Android instead of twice.
  • A team that grows into Flutter: your iOS and Android developers start on the simplest screens.
  • A way back: if a Flutter screen misbehaves, switching off its feature flag returns users to the native screen in minutes.

Why not?

The add-to-app approach:

  • Means running two worlds at once until the migration ends: both versions of migrated screens, duplicated tools and processes (design system, translations, analytics, crash reporting) and slower releases.
  • Moves most of the cost to the connection points between the existing app and Flutter rather than to building the screens themselves.
  • Doesn't provide the full opportunity to remove technical debt in the core of the existing app.
  • Takes experience to set up well and usually needs at least one senior Flutter engineer, in-house or from a partner.

Add-to-app is not automatically the safer choice. It pays off for large, stable apps that must keep shipping. For small apps or undocumented legacy code, a rewrite is often the better call.

When to use this approach

Below, we explore specific scenarios to help you decide when should you consider Flutter add-to-app:

Gradual migration of a large, stable app

Enterprises are often risk-averse, especially with mature native apps that still serve their users well. Rewriting a large app means more than the UI: years of edge cases, business logic and integrations live in the code, not in anyone's head. A rewrite has to recover all of that before the first release.

With add-to-app, screens or entire user flows move one at a time, each goes to production behind a feature flag and the native app keeps getting new features. You recover the knowledge hidden in the old code gradually, and your teams build hands-on Flutter experience before they reach the hardest parts.

Proof of concept (and a second chance for cross-platform)

Some enterprises have had poor experiences with cross-platform technologies, which left them skeptical of the whole approach. A proof of concept (PoC) puts one or a few Flutter screens into the real product, with real data and integrations. The native version stays, so a failed experiment costs little, and a successful one gives stakeholders something concrete to judge, often side by side with the native screen.

New features built once for both platforms

For new business features with complex UI (interactive charts, custom widgets, dashboards, marketing screens), Flutter can significantly speed up development compared to building the same feature twice in Swift and Kotlin. Teams build these modules with Flutter's fast development cycle and Hot Reload, then add them to the existing native app.

A new module with a single entry point – a loyalty program, a B2B portal, a new vertical – is the best case for add-to-app: practically a small Flutter app inside the native shell. The result: faster delivery to market, and code that's already in Flutter if you decide to go further.

Making the most of your native team

Your iOS and Android developers know your app, its business rules and its history better than anyone. Add-to-app keeps that knowledge in the project: they keep looking after the existing app while they learn Flutter on the simplest screens. Avoid splitting into an isolated “old native” team and a “new Flutter” team – that split is a risk of its own.

Hiring developers proficient in both native and Flutter can be costly. Our recommendation is to upskill your native team and add at least one senior Flutter engineer, in-house or from a partner, supported by internal workshops.

Backwards compatibility

Enterprises often need to maintain backwards compatibility with older versions of their apps or device-specific functionalities that are better handled in a native shell. Add-to-app makes this possible by letting Flutter modules live alongside native code. Users on older versions keep a stable native experience, while those on newer versions get the new Flutter-powered features.

This also allows you to target specific problematic areas of technical debt in the native app by replacing them with a fresh Flutter implementation, rather than attempting to fix issues across the entire codebase.

M&A context

Similar to the big-bang approach, add-to-app can also be highly relevant during mergers and acquisitions. When multiple development teams using different technologies (most often native) need to be unified, incrementally integrating Flutter provides a strategic way to consolidate efforts while managing risk.

This approach is especially valuable when immediate full consolidation isn't feasible or desirable, offering a smoother path toward alignment across teams and platforms.

Is Flutter Add-to-App ready for enterprise apps?

screen
circlecrossrectangletrianglesblock

How to plan an add-to-app migration

The hardest part of add-to-app is the plan, not the Flutter code. Teams that add Flutter screens at random end up paying for many extra connections between old and new code. Four decisions matter most.

Audit the native code first

Before you estimate anything, check what you're actually migrating: documentation, current designs, where the business rules live, which third-party services the app relies on and how much technical debt it carries. An estimate based on documentation can be badly off if the real behavior lives only in the old code. A technical feasibility analysis or a mobile app audit answers these questions before you commit.

Pick the first screen carefully

The first screen matters more than any other. A good start gives the team confidence and something in production. A bad one brings months of unplanned integration work and an argument for every skeptic.

Start at the edges, not the home screen

It's tempting to start with the screen that has the biggest business impact. That's usually a trap, because the most visited screen is usually the one most connected to everything else. Teams that start with standalone screens and new features, then move toward the center quarter by quarter, are slower at first but reach the end. Start with the module that has the cleanest architectural boundaries, not the most visible screen.

Move in waves and plan the exit from day one

After the first screen, group the rest into waves – sets of screens that move together and go live separately – starting with the most independent ones. Moving a whole user flow at once is often cheaper than moving its screens one by one, because the connections between them never have to be built.

Staying in add-to-app forever has a cost, so decide early when Flutter takes over. At that point, Flutter becomes the base of the app and the remaining old screens are opened from it. You don't need 100% Flutter to make the switch: rarely visited screens or parts closely tied to phone features can stay. Track the share of the app that's already in Flutter and identify the “last mile” screens early.

A typical add-to-app migration runs in four phases:

  1. Proof of concept – one or a few screens live for users, behind a feature flag.
  2. Foundation – the shared groundwork: connecting Flutter to the existing app, a Flutter version of your design system and the build and release process.
  3. Migration waves – user flows from the most independent toward the center of the app. This is the longest phase, and team size changes the schedule the most here.
  4. Exit – Flutter takes over the whole app, including its main navigation.

More on each step in our guide to planning an incremental migration from native to Flutter.

Tooling for add-to-app: Inlay and Converge

The official Flutter documentation covers the first steps. Beyond that, every team we've talked to ends up building the same connecting code by hand, project after project. That's why we built two tools out of our client work. Inlay handles the plumbing. Converge builds the plan.

Inlay is an open-source Flutter add-to-app framework. It gives your developers ready-made building blocks for connecting the existing app with Flutter – moving between screens and sharing data – so they don't build them from scratch, and it's designed to be easy to drop once the migration is done. It's free and available on GitHub.

Converge plans the migration itself. It reads your iOS and Android code with AI, matches each Android screen with its iOS counterpart and finds the screens only one app has. Algorithms calibrated on LeanCode's migrations then group the screens into waves, simplest first, with an estimate, a date and a team for each – and the same code always gives the same plan.

Every sprint, Converge reads your team's latest changes and recalculates the waves, the estimate and the end date, so the plan follows the actual work instead of a spreadsheet.

Converge

App migration strategy 3: Hybrid approach

Not every migration fits neatly into a single strategy. The hybrid approach blends the best of both worlds, combining elements of both the big-bang and add-to-app strategies. In practice, this often means building Flutter modules that integrate into your existing native app, while at the same time developing a new, parallel Flutter application based on the same shared codebase.

Why?

This approach offers:

  • A way to “test” Flutter in a real production environment and gather quick, real-life feedback.
  • Modules that are intentionally built to become part of a larger Flutter application later.
  • A natural evolution path from incremental integration to a full Flutter experience.

Why not?

The hybrid approach:

  • Requires managing the complexities of both integrating with an existing native app and building a new standalone app.
  • Can lead to increased coordination and overhead compared to a single, focused strategy.
  • May create inefficiencies in the early phases, as teams split efforts between integration and preparing for a full standalone app.

When to use this approach

Below, we outline scenarios where a hybrid approach can be the most effective migration strategy.

Risk mitigation

This strategy provides a strong safety net. By developing add-to-app modules that can also serve as building blocks for a standalone Flutter application, organizations can effectively “test” Flutter in a live production environment.

This approach enables the collection of real-world feedback on performance, user experience and development velocity, all without committing to a full migration upfront.

Verifying the Flutter hypothesis

The hybrid approach is an excellent way to validate the Flutter hypothesis in a real-world setting. If the add-to-app modules perform well and are positively received, it reinforces the case for a full migration. This gradual exposure builds confidence among decision-makers, demonstrating Flutter's capabilities and confirming its suitability for the organization's long-term strategy.

A planned switch to pure Flutter

The strength of this approach lies in its built-in flexibility. Since add-to-app modules are designed to fit within a larger Flutter application, moving from incremental integration to a full Flutter app becomes a natural next step rather than another disruptive rewrite. Decide early what will trigger the switch, so the two tracks don't run in parallel longer than needed.

At the same time, it enables organizations to retire legacy native code piece by piece, systematically eliminating technical debt while building a unified, modern Flutter codebase.

Application migration strategies: summary

When it comes to selecting the migration strategy for your app, there is no “right” answer across the board – only the right answer for your context. If you're drowning in technical debt, or your app is small enough to rebuild in a few months, the from-scratch path may be your lifeline. If your app is large and stable and has to keep shipping, add-to-app is usually the lower-risk path – as long as you plan the order of screens and the exit. If you want to test, learn and evolve toward a standalone Flutter app, hybrid may be the sweet spot.

To make the decision easier, we've summarized the key differences between the three application migration strategies below.

From scratchAdd-to-appHybrid
Best for
Apps with heavy technical debt, small apps or major product changesLarge, stable apps that must keep shippingTeams that want to validate Flutter while preparing for a full migration
Key advantages
Clean slate, modern architecture, single codebase, full controlGradual adoption, lower risk, faster initial results, a way back through feature flagsFlexibility, real-world testing, smooth transition to full Flutter
Main drawbacks
High upfront cost, longer time to market, higher execution riskTwo worlds to maintain until the exit, extra work connecting old and new code, limited ability to remove technical debtHigher complexity, requires strong coordination
Your app during the migration
Native apps maintained in parallel until an all-or-nothing launchKeeps shipping; Flutter screens go live one by one behind feature flagsKeeps shipping while a standalone Flutter app is built in parallel
What decides success
Recovering all business logic before the first releaseThe order of screens and a planned exitCoordination between modules and the standalone app, and a clear switch moment
Risk level
HighLow–MediumMedium

The key is alignment: business leaders and technical leaders must make this choice together. Because the path you select won't just shape your app – it will shape your ability to move fast, innovate and compete for years to come.

If add-to-app looks like your path, our free Flutter add-to-app guide covers the strategy, the architecture and the tooling in depth.

Rate this article
Star 1Star 2Star 3Star 4Star 5
5.00 / 5 Based on 3 reviews

You may also like

10 Most Common Objections to Flutter - LeanCode

Concerned About Flutter? A Reality Check on the 10 Most Common Objections to Flutter

Over the years, Flutter has faced its share of skepticism. Some concerns were valid back in the early days. Many are now outdated, yet they still appear in conversations. We analyze the most common objections to Flutter and explain their implications for Flutter app development.

Technical Feasibility Analysis for Flutter Migration

Technical Feasibility Analysis Before Migrating to Flutter: Why It Matters

Migrating a mobile app to Flutter can be a smart move – faster development, one shared codebase, and lower long-term maintenance costs are hard to ignore. But before making that decision, there’s an important reality check that needs to happen. Read about technical feasibility analysis.

Trends in Flutter app development

What Are the Current Trends in Flutter App Development? LeanCode's Top Picks for 2026

Flutter app development is evolving quickly, with new trends and technologies emerging all the time. Based on our experience delivering Flutter apps in real production environments, we explore what’s shaping how teams build and maintain Flutter products in 2026.