How to hire Xamarin developers: a practical guide for U.S. engineering and HR leaders.
Nobody starts a new app in Xamarin in 2026. Companies hire Xamarin developers because they already have one in production: a field-service app, a patient portal, a sales tool, often built between 2015 and 2020 and still used every day. Microsoft ended Xamarin support on May 1, 2024 (Microsoft Xamarin support policy), and in 2026 both app stores raised their build requirements past what the last Xamarin SDKs can produce. The job now is to keep that app working for the people who depend on it and move it to a supported stack. This guide covers how to hire for that.
What Xamarin developers do now
Xamarin let teams write iOS and Android apps in C#. It came in two forms: Xamarin.iOS and Xamarin.Android, which wrap each platform's native APIs, and Xamarin.Forms, a shared UI layer on top of them. Both now have successors inside .NET. Xamarin.iOS and Xamarin.Android became .NET for iOS and .NET for Android starting with .NET 6, and Xamarin.Forms evolved into .NET MAUI (.NET Multi-platform App UI).
So a Xamarin developer in 2026 does three things. They keep the current app stable for users: crashes, backend changes, device issues. They move it to .NET for iOS and Android or to .NET MAUI so it can ship again. And they own the release process afterward, because .NET MAUI ships a new major version every year. If most of your .NET work is on the web and API side rather than the app, you are looking for .NET developers instead.
The deadlines your app faces
| Date | What happened | What it means for a Xamarin app |
|---|---|---|
| May 1, 2024 | Xamarin support ended (Microsoft) | No fixes or security updates. Last SDKs target Android API 34 and Xcode 15. |
| March 31, 2025 | App Center Build, Test, Distribution and CodePush retired (Microsoft Learn) | Many Xamarin teams built and distributed through it. The pipeline has to be rebuilt. |
| April 28, 2026 | App Store uploads must use the iOS 26 SDK (Apple) | A Xamarin.iOS build cannot meet it. |
| August 31, 2026 | Google Play updates must target API 36 (Google Play) | A Xamarin.Android build cannot meet it. Extensions run to November 1, 2026. |
| March 31, 2027 | App Center Analytics and Diagnostics end | Crash reporting has to move before then. |
| May 11, 2027 | .NET MAUI 10 support ends (Microsoft) | Even after migrating, plan an upgrade every year. |
The last row is the one teams miss. A .NET MAUI major version is supported for at least six months after its successor ships, which in practice means about 18 months. .NET MAUI 9 already reached end of support on May 12, 2026. Migrating off Xamarin is a one-time project; staying current on .NET MAUI is a yearly one.
.NET MAUI, native or rewrite
| Path | Keeps | Best when | Watch out for |
|---|---|---|---|
| Xamarin.Forms to .NET MAUI | C# UI and business logic, most XAML | Forms-heavy business apps, a .NET backend team, limited budget for a rewrite | Renderers, packages without a .NET MAUI version, layout differences |
| Xamarin.iOS/Android to .NET for iOS/Android | Native UI code and C# logic | Apps already written against native APIs in C# | Bindings and build tooling still need work |
| Rewrite in React Native | Your API; UI and logic are rebuilt | A React web team that will own the app | A full rewrite, usually run in phases |
| Rewrite in Swift and Kotlin | Your API | Highly custom UI, heavy device features, new platform APIs on release day | Two codebases and two teams |
| Rewrite in Flutter | Your API | A fresh start with identical UI on both platforms | A new language (Dart) for your team |
There is no universal answer. A .NET MAUI migration is usually the shortest route back to the stores for a Xamarin.Forms app, and Microsoft's own guidance is that projects don't need to be rewritten (Microsoft Learn). A rewrite makes sense when the app would need a major redesign anyway. If you go that way, see how we vet React Native engineers, native iOS engineers and Android engineers.
The four profiles
| Profile | Owns | Typical stack | Hire when |
|---|---|---|---|
| Xamarin.Forms to .NET MAUI engineer | The shared UI project, renderers, packages, the migration plan | Xamarin.Forms, .NET MAUI, XAML, MVVM (Prism, CommunityToolkit.Mvvm) | Your app is built on Xamarin.Forms |
| Native Xamarin engineer | Platform code, bindings to native SDKs | Xamarin.iOS, Xamarin.Android, .NET for iOS and Android, Objective-C and Java/Kotlin bindings | Your app uses native Xamarin or depends on vendor SDKs |
| Full stack mobile .NET | The app and the ASP.NET Core API behind it | .NET MAUI, ASP.NET Core, EF Core, SQLite, Azure | One team owns app and backend |
| Mobile release engineer | Signing, builds, store releases, crash reporting | Azure Pipelines or GitHub Actions, Mac build agents, TestFlight, Google Play Console | App Center is gone and nobody owns the pipeline |
Seniority you need
- Mid-level engineers fix bugs and build screens in an existing Xamarin or .NET MAUI app once the patterns are set.
- Senior engineers run the migration: audit dependencies, decide which renderers to reuse and which to port, get the app building on current SDKs and through store review. This is the level most teams need first.
- Lead engineers decide between .NET MAUI and a rewrite, sequence the work against the roadmap, and own releases and the yearly upgrade. If the mobile app is one part of a larger platform decision, that is architecture work.
Years of Xamarin experience are a weak signal. Six years maintaining one Xamarin.Forms app is a different profile from three years that include a completed migration to .NET MAUI.
One developer or a team
One senior engineer can take a small or medium Xamarin.Forms app to .NET MAUI and get it releasable. Add people when there are several apps (a portfolio of internal tools is common), when native bindings to vendor SDKs are involved, or when the business will not accept a feature freeze during the migration. A common shape is two senior mobile .NET engineers, one of them owning the pipeline, plus QA on physical devices. If the backend also needs work, a full stack .NET engineer covers the API side.
Job description essentials
- Current stack: Xamarin.Forms or Xamarin.iOS/Android, Xamarin version, MVVM framework, how many apps.
- Target: .NET MAUI, .NET for iOS and Android, or a rewrite, and whether that is decided.
- The hard parts: number of custom renderers and effects, native SDK bindings (payments, scanners, maps), packages you know are abandoned.
- Release process: how you build and sign today, who owns the Apple and Google accounts, whether App Center was part of it.
- Backend: the API the app talks to, and whether this role touches it.
- AI tooling: which coding assistants the team uses and how generated code is reviewed.
- Team and hours: team size, reporting line, required overlap with U.S. hours.
Say plainly that the role starts with a migration. Engineers who have done one look for that; engineers who want greenfield work will not last.
Skills, layer by layer
C# and .NET
- async/await in UI code: keeping work off the main thread without deadlocks.
- Dependency injection: .NET MAUI builds the app through
MauiProgramand a host builder, which replaces mostDependencyServiceusage. - Memory and lifecycle: event handler leaks, page lifetimes,
IDisposable.
Xamarin.Forms and .NET MAUI
- XAML, data binding and MVVM, including moving from
MessagingCenter(deprecated, and no longer public in .NET 10) to a messenger such asWeakReferenceMessenger. - Handlers and property mappers, and when a shimmed renderer is good enough for now.
- Xamarin.Essentials APIs and where they live in .NET MAUI.
- Shell navigation,
CollectionViewinstead ofListView, and layout differences after the port.
Platform layer
- iOS: provisioning, entitlements, Info.plist, privacy manifests, building on a Mac with the Xcode version the .NET iOS workload expects.
- Android: target API changes, permissions, AndroidManifest, Java and Kotlin library bindings.
Dependencies and bindings
- Auditing NuGet packages for .NET MAUI support and finding maintained replacements.
- Rebuilding bindings for native SDKs, or wrapping them with a thin native layer.
Delivery
- CI/CD in Azure Pipelines or GitHub Actions, code signing, TestFlight and Google Play tracks.
- Crash reporting and analytics after App Center.
AI-assisted work
- Using assistants for namespace and API conversions, then checking each one on a device. Generated migration code often compiles against the wrong API or hides a platform difference.
How to interview
- 1Screen (30 min)Walk through a Xamarin or .NET MAUI app they shipped. What was in the shared project, what was platform code, and how releases worked.
- 2Live exercise (60 to 90 min) in C#Extend an existing solution without rewriting it. For a mobile role, a small Xamarin.Forms or .NET MAUI page with a view model, a service call and an error state works well.
- 3Migration review (30 min)Give them a Xamarin.Forms custom renderer, a
DependencyServicecall and apackages.configwith a package that has no .NET MAUI version. Ask for a migration plan. - 4Team conversationHow they would explain to a product manager why the next release waits for the migration's first milestone.
If you are rewriting instead, interview in the target stack, and ask one question about the Xamarin app: what it does that the rewrite must not lose.
Interview questions
- Our Xamarin.Forms app has 15 custom renderers. How do you approach them in .NET MAUI?Best answerInventory first, reuse the ones .NET MAUI can shim to ship sooner, port the rest to handlers by risk and usage, test each on both platforms.
- A NuGet package we depend on has no .NET MAUI version. What do you do?Best answerCheck for a maintained fork or successor, look at what the app actually uses, consider replacing with a platform API or a small wrapper, and never block the whole migration on it.
- How do you replace
DependencyServicein .NET MAUI?Best answerRegister services inMauiProgramand inject them, with platform implementations through partial classes or conditional registration. KnowsDependencyServicestill exists but is not the default. - What is the difference between Xamarin.Android and .NET for Android?Best answerThe same platform wrapper moved into .NET: SDK-style projects,
net10.0-androidtarget frameworks, current Android APIs. Code mostly carries over; project files and tooling do not. - The app compiles on .NET MAUI but screens look different. Why?Best answerDefault layout values and control behavior changed between Xamarin.Forms and .NET MAUI. They test on devices and fix spacing and sizing explicitly.
- How would you ship iOS and Android releases without App Center?Best answerA pipeline in Azure Pipelines or GitHub Actions with a Mac agent for iOS, signing handled as secrets, uploads to TestFlight and Google Play tracks, crash reporting set up separately.
- When would you not migrate to .NET MAUI?Best answerA strong candidate names real cases: a planned redesign, a React team taking over, heavy platform-specific UI. Shows judgment, not loyalty to a framework.
Red flags
- Their last Xamarin work is years old and they have no view on .NET MAUI.
- They cannot describe how their app was built, signed and released.
- Every answer to a migration question is "rewrite it", or never is.
async voidand.Resultin exercise code outside event handlers.- They have never tested on a physical device.
- They accept an AI-converted project because it compiles.
What it costs
The U.S. median base salary for software developers is $135,980 (BLS, May 2025), before payroll taxes, benefits, equipment and recruiting. Engineers who have led a Xamarin migration are a smaller group, and senior U.S. profiles with that experience usually sit above the median.
A senior LatAm Xamarin developer through BEON.tech is priced on our .NET rate: $6,200 to $7,600 per month, all-inclusive ($74,400 to $91,200 per year). React Native, iOS and Android engineers for a rewrite are priced on their own stack. Use the LatAm developer cost calculator to compare by country and seniority.
Nearshore in LATAM
Latin America works in U.S. hours, 0 to 4 hours from Eastern time. For a mobile team that matters on the days with the most risk: a store rejection, a signing failure the night before a launch, a crash spike after an update. Our network includes more than 1,300 engineers with Xamarin or .NET MAUI in their work history, about half of them senior or above, inside a much larger .NET pool. For a broader view of mobile hiring with BEON.tech, see our mobile app development page, and for the region, our guide to hiring Latin American developers.
Hiring model comparison
| Model | Speed | Vetting done for you | Payroll & compliance | Best for |
|---|---|---|---|---|
| In-house U.S. hire | Slowest | No | You | Roles that must be U.S.-based |
| Freelance marketplace | Fast | Partial, résumé level | Contractor | A small, well-defined fix |
| Xamarin development company (project outsourcing) | Weeks to scope | The vendor's own process | Vendor | A fixed-scope migration you hand off entirely |
| Staff augmentation (BEON.tech) | 24–48h shortlist, 2-week start | Yes, live interview + recording | BEON.tech | Migration plus ongoing work inside your own team |
| Contract-to-hire (BEON.tech) | Same as staff augmentation | Yes | BEON.tech, then you | A first migration milestone you want to see delivered |
| IT recruitment (BEON.tech) | Shortlist first, then your process | Yes | You | A mobile lead who will own the app long term |
The first 90 days
- Week 1Repository and store account access, the current app building locally, a list of every NuGet package, renderer and native binding. First small fix merged.
- Weeks 2 to 4A migration plan with milestones, and the app building on .NET for iOS and Android or .NET MAUI in a branch.
- Month 2The first release from the new stack through TestFlight and Google Play testing tracks, with crash reporting in place.
- Month 3A production release from the new stack, the pipeline documented, and a date for the next .NET MAUI upgrade on the roadmap.
Hiring with BEON.tech
Tell us what your Xamarin app does, which stores are blocked, and where you want to land: .NET MAUI, native or React Native. Within 24 to 48 hours you get two or three senior engineers, each with the recording and scorecard of a live interview in the stack they would use. Most engineers start within two weeks, and 88% are still on the team after year one.




























