Cross-Platform Mobile App Development with .NET MAUI
We develop cross-platform mobile applications on .NET MAUI — a single codebase for iOS, Android, and Windows. If your team already uses C# and ASP.NET Core, MAUI is a natural extension: the same patterns, same DI container, same NuGet. For enterprises where the mobile app is a frontend to a .NET backend, this is the optimal path in terms of team unification and code reuse.
.NET MAUI is the direct successor of Xamarin.Forms, but architecturally reworked. Instead of separate projects for each platform — a single csproj with conditional dependencies. This means one appsettings.json, one DI container (Microsoft.Extensions.DependencyInjection), one set of models. The transition is minimal: the patterns are the same, the tooling (latest Visual Studio / Rider) is the same.
Why .NET MAUI is faster than Xamarin.Forms?
MAUI uses Handlers instead of Renderers, reducing the view hierarchy by 2–3 levels and decreasing overhead by 30–50%. In practice, this means smoother scrolling and lower memory usage. Microsoft Learn: .NET MAUI Handlers.
Where Real Problems Arise
Hot Reload comes with caveats. XAML Hot Reload in the latest Visual Studio versions handles simple markup changes fine. But changes in C# code-behind or view models require a restart — .NET Hot Reload in MAUI is unreliable for complex hierarchies. UI iteration takes longer than in Flutter or React Native.
Binary size. A basic .NET MAUI APK without trimming is 30–50 MB. With PublishTrimmed=true and RuntimeIdentifier=android-arm64 we can compress it to 15–25 MB. However, trimming breaks Reflection, on which some NuGet packages rely. Every package must be checked for AOT/trimming compatibility.
NativeAOT on iOS is available with the latest .NET version. It gives better startup time and size, but requires complete abandonment of runtime Reflection. If the project uses System.Text.Json with source generators — fine. If Newtonsoft.Json — migration is mandatory.
Trimming compatibility check
Add `How .NET MAUI handles offline mode?
Corporate app for field inspectors: offline work with forms and photos, synchronization when network appears. Stack: MAUI + EF Core SQLite + Polly for retry queue + Microsoft.Maui.Essentials for camera and GPS access. Platform-specific part: only file system access (different paths on iOS Documents vs Android GetExternalFilesDir). Compared to Xamarin.Forms, platform-specific code volume decreased by 40%. CI — Azure DevOps Pipelines with dotnet publish tasks per platform, signing via KeyVault.
Stack and Architecture
MVVM is the standard for MAUI. CommunityToolkit.Mvvm covers 90% of needs: [ObservableProperty], [RelayCommand], [NotifyCanExecuteChangedFor] via source generators. No manual INotifyPropertyChanged boilerplate.
Shell navigation (Shell) for standard cases; for complex navigation with object passing — NavigationPage or ReactiveUI.Maui. Prism.Maui — if the team is familiar with it from WPF/UWP.
Network layer — HttpClientFactory via DI, Refit for typed REST clients, Polly for retry/circuit breaker. gRPC client via Grpc.Net.Client works on iOS and Android without extra configuration starting from a certain .NET version.
Local DB — SQLite-net-pcl for simple cases, LiteDB for document-oriented storage. Entity Framework Core with SQLite provider works, but in trim scenarios requires EFCore.TrimmingSupport.
Push notifications — Plugin.Firebase.CloudMessaging for FCM; APNs on iOS configured via UNUserNotificationCenter in MauiProgram.cs.
Platform Integration
Access to native APIs — via Microsoft.Maui.Essentials: geolocation, accelerometer, Bluetooth, camera, biometrics (SecureStorage + Fingerprint). If access beyond Essentials is needed — DependencyService with platform-specific implementations or direct native code calls via #if ANDROID / #if IOS in partial classes.
Bindings to native SDKs: on Android — Java/Kotlin Binding Library via Binding Project; on iOS — ObjectiveC/Swift Binding via ApiDefinitions.cs. The procedure is labor-intensive but well-established.
Timelines
| Scope | Timeline |
|---|---|
| Corporate MVP, 8–12 screens | 8–14 weeks |
| Product with offline and sync | 4–7 months |
| Platform with enterprise system integration (SAP, 1C) | 6–12 months |
Cost is calculated individually after analyzing requirements and the client's existing .NET infrastructure. Contact us for a preliminary estimate.
What's Included in Development
- Source code in a repository (Git) with commit history;
- CI/CD pipeline (Azure DevOps / GitHub Actions) with signing and deployment;
- Architecture and API documentation;
- Setup of App Store Connect and Google Play Console (client accounts);
- Training the support team (2–3 sessions);
- Warranty for bug fixes within 30 days after delivery.
Order turnkey development — get a release-ready application.
What We Focus on During Audits
Three things we most often see in legacy MAUI projects: lack of trimming compatibility (app weighs 60+ MB), use of outdated Renderer from Xamarin.Forms instead of migrating to Handler, and synchronous DB operations on the UI thread via EF Core without async/await. The last one guarantees ANR on Android. We help migrate and optimize — write to us.