Photo: Google Gemini · AI-generated
New to this topic? Start here
Terms used in this piece
- Xamarin / Xamarin.Forms
- Microsoft's earlier framework for building iOS, Android and Windows apps from one C# codebase; it is no longer supported.
- .NET MAUI
- Xamarin's successor: the current Microsoft framework for the same job, built on modern .NET.
- Renderer / handler
- The code that turns a shared control into the native one on each platform; Xamarin used renderers, MAUI uses handlers, so custom ones must be rewritten.
- Target API level
- The Android version an app declares it was built for; Google Play raises the minimum every year.
- CI/CD pipeline
- An automated chain that builds, tests and delivers each change, so new versions reach testers and users without manual steps.
Read first
- Upgrade from Xamarin to .NET and .NET MAUI ↗Microsoft's own migration guide; the place to start before estimating anything.
Microsoft ended support for Xamarin on 1 May 2024. Apps built with it did not stop working that day, and that is the problem. An app that still runs never feels urgent, so the move to .NET MAUI gets pushed to next quarter, and then the one after.
Then something outside your control forces it. Google Play raises the minimum Android version an app must target every year. Apple regularly requires App Store uploads to be built with a recent Xcode and SDK. Sooner or later an update you need to ship cannot be built with tools that no longer get updates, and the migration starts under time pressure instead of on your schedule.
What the upgrade tool does, and what it does not
Microsoft offers a migration guide and an Upgrade Assistant that converts project files and renames namespaces. It is useful. It is also honest about its limits: Microsoft’s own guide says that after the tool runs, most apps still need more work to complete the upgrade.
That remaining work usually sits in three places:
- Custom renderers. Anything that made a control look or behave differently per platform was a renderer in Xamarin. MAUI uses handlers instead. Every custom renderer is a small rewrite, and older apps have more of them than anyone remembers.
- Third-party packages. Each library the app depends on needs a version that supports modern .NET, or a replacement. One abandoned package can hold up the whole move.
- Platform code. Background sync, file access, push notifications and anything else that talks to the operating system directly needs testing on real devices, because that is where behaviour changed.
None of this is hard. All of it is easy to underestimate when the estimate is based on the tool’s output.
How we did it on an app that could not stop
Our longest-running example is a subcontractor portal for a German construction company with up to 500 employees. Project managers use the web portal in the office. Subcontractors use native iOS, Android and Windows apps on site, often without a connection, so the apps work offline and sync when the network comes back. We have been responsible for the portal since its second generation; it is now in its fourth.
The field app started as a native Android app and moved to one Xamarin codebase for iOS, Android and Windows; along the way the backend moved from PHP and MySQL to .NET and SQL Server. Moving the apps from Xamarin to MAUI was the latest of those steps. The apps were in daily use on building sites the whole time, so the migration had to happen next to production, not instead of it. Three things made that possible.
We waited until MAUI was ready. We did not move when MAUI first shipped. We moved when it was stable enough for an offline-first app that people depend on. Being early is a cost the client pays.
The pipeline was already there. The portal has an Azure DevOps pipeline with separate dev, QA, test and live environments, and the iOS and Android builds go out through Firebase App Distribution, which keeps test and pilot builds separate from what ships to production. A MAUI build could go to pilot users and be checked against the test environment while everyone else kept working with the live version.
Offline sync is what has to be proven. The visible screens are the easy part to check. What breaks users’ trust is data that does not arrive after a day in a basement without signal. In an app like this, sync deserves more testing than any screen.
When to start
Start before a store requirement starts it for you. A sensible first step is a short assessment: list the custom renderers, the third-party packages and the platform-specific code, and check each package for a supported version. That list turns “we should migrate at some point” into a plan with a size.
It is also the kind of question our Modernisation Assessment answers in four weeks at a fixed price. If you already know the size, send us the app’s package list and we will tell you where we expect the surprises.
Go further
- Software modernisation: how we approach itThe service page, with the fixed-price Modernisation Assessment as the first step.
- Case study: Subcontractor PortalThe project behind this article: web portal plus native iOS, Android and Windows apps for a construction company.
- Modernisation is continuous, not a one-time projectThe same portal across four generations, and why we think that is the normal case.
Sources
- Xamarin support ended on May 1, 2024, Microsoft .NET
- Upgrade from Xamarin to .NET and .NET MAUI, Microsoft LearnSource for the Upgrade Assistant and for the note that most apps need further work after it runs.
- Target API level requirements, Android Developers
- SDK minimum requirements, Apple Developer
