A mobile app ages on a schedule that its owner does not control. Apple and Google raise their requirements every year, frameworks reach end of support, and an app that still works can become impossible to update. This guide is about the decision that follows: which path to take for an existing app, what each path keeps and throws away, and how to ship the result without users noticing anything except the improvement.
Why mobile apps force the decision
A back-end service can run unchanged for years. A mobile app cannot, for three reasons that have nothing to do with the quality of its code.
- Store requirements move every year. Google Play requires app updates to target a recent Android API level, and Apple requires submissions to be built with a recent SDK. An app that cannot be rebuilt with current tools cannot be updated, even for a one-line fix.
- Frameworks end. Microsoft ended support for Xamarin on May 1, 2024. Xamarin apps keep running on phones, but the tools needed to build them for new operating system versions are no longer maintained.
- The operating system changes under the app. New permission models, background execution limits and screen sizes arrive whether the app is ready or not.
The practical consequence: for a mobile app, doing nothing is not a stable option. The question is which change to make, not whether to make one.
Which situation are you in
| Situation | Typical sign | What is at stake |
|---|---|---|
| Framework out of support | Xamarin.Forms or Xamarin native app | The app can no longer be built for current OS versions |
| Two native codebases | Separate Swift and Kotlin teams for one product | Every feature is paid for twice and ships at different times |
| Hybrid web wrapper | Cordova or an early Ionic app | Performance and platform features lag behind user expectations |
| Cross-platform app that no longer fits | A working app on a stack the team cannot hire for | Delivery slows down although the code is fine |
| Sound app, legacy back-end | The app is modern, the API behind it is not | The app is not the thing to modernize |
The last row matters more than it seems. If the app is slow because the API is slow, a new mobile framework changes nothing. In that case start with the back-end: see Legacy System Modernization Strategy.
The paths
| Path | What it means | What is kept | What is rewritten |
|---|---|---|---|
| Upgrade in place | Move to the successor of the same framework, for example Xamarin.Forms to .NET MAUI | Language, most business logic, view models, much of the UI markup | Project structure, platform-specific code, custom renderers, some libraries |
| Switch cross-platform framework | Move between frameworks, for example .NET MAUI to React Native or Flutter | API contract, behaviour, design, test scenarios | All app code, in a new language |
| Go native | Separate Swift and Kotlin apps | API contract, behaviour, design | All app code, twice |
| Share logic, keep native UI | Kotlin Multiplatform under native screens | Native UI on both platforms | Business logic, once, into a shared module |
| Replace with a web app | A responsive or installable web application | Back-end, content | The app itself; store presence is usually given up |
The paths differ most in one respect: how much working code survives. Upgrading in place keeps the most and is the only path where the result can be compared with the original almost line by line. Every other path is a rewrite with a specification, where the specification is the existing app.
How to choose
- What your team writes every day. A .NET team will maintain a .NET MAUI app. A team of web developers will maintain a React Native app. The framework the team already knows wins more often than the framework with the better benchmark.
- How much of the app is platform-specific. Camera pipelines, Bluetooth, background location and custom rendering are where cross-platform frameworks cost the most. If that is most of the app, native is the honest choice.
- How long the app has to live. For a product with a ten-year horizon, the hiring market and the vendor’s commitment matter more than the migration effort.
- Whether an upgrade path exists. If the framework has a supported successor, upgrading in place is usually the cheapest way to get back onto supported ground, even when a bigger change is planned later.
- What the back-end already offers. A clean, documented API makes every path cheaper. An app that talks to SOAP services or reads a database directly needs that fixed first.
A common and sensible sequence is two steps instead of one: first upgrade in place to get out of the unsupported state, then decide about a framework change without a deadline from the stores.
What carries over and what does not
Estimates for mobile migrations go wrong in a predictable way: the screens are counted, and the parts without screens are forgotten.
| Usually carries over | Usually does not |
|---|---|
| Business rules and validation | Custom controls and platform renderers |
| API clients and data models | Navigation and deep linking |
| View models, if the app has them | Push notification registration |
| Test scenarios | Local database and secure storage access |
| Design and copy | Build pipeline, signing and store configuration |
The right-hand column is where the schedule is decided. An app with thin screens and many platform integrations is a larger project than an app with fifty simple screens.
Releasing without losing users
A server can run old and new versions side by side and move traffic gradually. A phone runs one binary. That changes how a mobile migration is released.
- Keep the application identifier. The new app must ship as an update of the old one, with the same bundle ID and signing identity. A new listing means every user has to find and install it again.
- Migrate what is stored on the device. Login tokens, local databases and preferences were written by the old app in its own format. The first start of the new version has to read them, or every user is logged out and offline data is gone.
- Re-register push notifications and re-test deep links. Both are tied to the old implementation and fail silently.
- Use staged rollout. Both stores allow releasing to a percentage of users. It is the mobile substitute for gradual traffic shifting.
- Keep the API contract fixed during the migration. Changing the app and its API at the same time removes the only stable reference point.
- Compare analytics before and after. Crash rate, start time and funnel completion show whether the new app is actually equivalent.
Where the app is large, a framework can also be introduced screen by screen inside the existing app, with both technologies shipping in one binary for a while. It is the closest mobile equivalent of the strangler approach described in the monolith to microservices guide, and it costs build complexity in exchange for smaller releases.
Testing a migrated app
- Logic tests for rules, view models and API clients. These run on a build server without a device and should exist before the migration starts.
- The same scenarios against both versions. Written once, as user-level steps, they are the definition of done for a rewrite.
- Upgrade tests. Install the old version, create data, update to the new version, check that the data is there. This test is skipped more often than any other and catches the most expensive defects.
- A device matrix that includes the oldest operating system version you still support, not only current flagships.
Where mobile modernization fails
- The estimate covered screens and left out storage, notifications and the build pipeline.
- The new app shipped under a new identifier, and the user base had to be rebuilt.
- The framework was chosen for its popularity, and the team that has to maintain it had never used it.
- The app and its back-end were changed in the same release, so no one could tell which one caused a defect.
- The first version was released to all users at once.
Worked examples
Each case is a runnable project on GitHub with the app before the change, the app after it, and tests that both versions must pass.
- Xamarin.Forms to .NET MAUI: A Worked Migration with Shared Tests: the same 11 screen-level scenarios compiled against both sets of view models, what they found in the old app, and what could not be verified without a device.
- .NET MAUI to React Native: A Worked Rewrite Checked by the Same Scenarios: the same app rewritten in TypeScript, with the 11 scenarios ported to run against the new screens and a migration of what the old app stored on the device.
Ready to compare implementation partners? See our overview of top legacy modernization companies, and for apps on the Microsoft stack the top .NET modernization companies.
FAQ
Is Xamarin still supported? No. Microsoft ended support for Xamarin on May 1, 2024. Existing apps continue to run, but the tooling no longer receives updates for new operating system versions. The supported successor is .NET MAUI.
Is moving from Xamarin.Forms to .NET MAUI a rewrite? No. It is an upgrade in place. The language stays, and business logic and view models largely carry over. The project structure, platform-specific code and custom renderers need work, and each third-party library has to be checked for a .NET MAUI version.
Should we go native or cross-platform? It depends on how much of the app is platform-specific and what your team maintains well. Apps built around device hardware or custom rendering tend to be cheaper as native apps over their lifetime. Apps that are mostly forms, lists and API calls are usually cheaper on one shared codebase.
Can the old and the new app run side by side? Not as two installed apps without losing users. What works is shipping the new implementation as an update of the same app, released to a growing percentage of users, or introducing the new framework screen by screen inside the existing app.
What is the most common mistake? Forgetting the data on the device. If the new version cannot read what the old version stored, every user is logged out on update and offline data is lost.