Mobile App Modernization: Choosing a Path for Xamarin, Native and Cross-Platform Apps

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

SituationTypical signWhat is at stake
Framework out of supportXamarin.Forms or Xamarin native appThe app can no longer be built for current OS versions
Two native codebasesSeparate Swift and Kotlin teams for one productEvery feature is paid for twice and ships at different times
Hybrid web wrapperCordova or an early Ionic appPerformance and platform features lag behind user expectations
Cross-platform app that no longer fitsA working app on a stack the team cannot hire forDelivery slows down although the code is fine
Sound app, legacy back-endThe app is modern, the API behind it is notThe 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

PathWhat it meansWhat is keptWhat is rewritten
Upgrade in placeMove to the successor of the same framework, for example Xamarin.Forms to .NET MAUILanguage, most business logic, view models, much of the UI markupProject structure, platform-specific code, custom renderers, some libraries
Switch cross-platform frameworkMove between frameworks, for example .NET MAUI to React Native or FlutterAPI contract, behaviour, design, test scenariosAll app code, in a new language
Go nativeSeparate Swift and Kotlin appsAPI contract, behaviour, designAll app code, twice
Share logic, keep native UIKotlin Multiplatform under native screensNative UI on both platformsBusiness logic, once, into a shared module
Replace with a web appA responsive or installable web applicationBack-end, contentThe 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 overUsually does not
Business rules and validationCustom controls and platform renderers
API clients and data modelsNavigation and deep linking
View models, if the app has themPush notification registration
Test scenariosLocal database and secure storage access
Design and copyBuild 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.

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.


Sources and further reading

Eugene started his career at Chudovo in 2015. The expert is responsible for advisory services that include but are not limited to close communication with the clients, analyzing their needs, designing tailored software strategies, etc. Throughout the practice at Chudovo, an IT consultant took part in over 17 projects, covering a wide range of client services and solving customer pains from the business perspective. With Eugene’s involvement, the customers were able to build an efficient strategy for business growth as well as to set up a long-term technology roadmap. Eugene takes an active part in software development projects in the role of IT consultant and composes proposals for the customers.