Developer planning .NET MAUI cross-platform app architecture at a laptop

The pitch for .NET MAUI sounds almost too good: one C# codebase, four platforms, native performance. Every experienced developer has been burned by a framework that overpromised and underdelivered — so let's skip the marketing slide and get into the actual mechanics.

I've shipped MAUI apps that run on iOS, Android, Windows, and macOS. The “60% time savings” claim is real — but only under specific conditions. Here's what those conditions are, and how to engineer your project to meet them.

What the “60% Time Savings” Actually Means

The 60% figure isn't a marketing number pulled from thin air. It reflects a real phenomenon: when you build well-structured MAUI apps, you genuinely share 80–95% of your codebase across platforms. The savings come from not writing — and not maintaining — four separate implementations of the same logic.

But the key word is well-structured. Poorly structured MAUI projects can achieve as little as 50–60% code sharing, which narrows the advantage significantly. The teams who see the largest gains are the ones who know exactly what to centralise and what to leave platform-specific.

What You Can (and Can't) Share Across Platforms

Being honest about this upfront is what separates efficient MAUI projects from frustrated ones.

You can share almost everything in the business layer:

  • All business logic, validation rules, and data transformations
  • ViewModels and all MVVM plumbing
  • Service layer: API clients, repositories, caching logic
  • Navigation logic (Shell routes)
  • Most UI — pages, layouts, controls defined in XAML
  • Resource files: strings, colours, styles, fonts

What typically needs platform-specific treatment:

  • Custom native UI controls (reaching down to UIKit, Jetpack Compose, or WinUI)
  • Push notification registration (APNs vs. FCM vs. WNS)
  • Platform-specific permissions flows (iOS camera access request vs. Android)
  • Hardware APIs: biometrics, barcode cameras, NFC, background location
  • App Store-specific requirements: in-app purchases, review prompts

How to Structure a MAUI Project for Maximum Code Reuse

The project structure is where most teams either compound or resolve their problems:

MyApp/
├── Platforms/
│ ├── Android/ ← Android-specific code only
│ ├── iOS/ ← iOS-specific code only
│ ├── Windows/ ← Windows-specific code only
│ └── MacCatalyst/
├── Features/ ← Feature-first organisation
│ ├── Dashboard/
│ ├── Profile/
│ └── Orders/
├── Services/ ← Shared abstractions + implementations
├── Models/ ← Shared data models
├── Resources/ ← Fonts, images, styles, strings
└── MauiProgram.cs ← DI registration + app setup

CommunityToolkit.Mvvm — Your Biggest Productivity Booster

If there's one NuGet package that pays for itself in the first hour, it's CommunityToolkit.Mvvm. It uses C# source generators to eliminate most of the MVVM boilerplate that would otherwise bloat your ViewModels.

[ObservableProperty]
private string _userName = string.Empty;

[RelayCommand]
private async Task LoadProfileAsync()
{
    UserName = await _profileService.GetNameAsync();
}

How to Handle Platform-Specific Code Without Spaghetti

Even in a well-shared codebase, you'll need platform-specific behaviour. The clean way to handle this is through interfaces and partial classes — not #if ANDROID directives scattered through shared code.

The Rule of Thumb

If you catch yourself writing #if ANDROID or #if IOS in a shared service or ViewModel, stop and extract an interface instead.

Performance Strategies That Actually Matter

  • Compiled Bindings: Add x:DataType to your XAML data templates for compile-time binding validation.
  • CollectionView over ListView: Always use CollectionView for scrollable lists — it uses native view recycling.
  • Shell Lazy Loading: Register pages as lazy in Shell so they're only initialized upon navigation.
  • Image Optimization: Use SVG files for icons; MAUI automatically generates the required platform densities.

What Senior MAUI Teams Do Differently

  • They define service interfaces before writing XAML. Architecture drives the UI.
  • They write unit tests for ViewModels and services from day one. Pure C# logic is easily tested.
  • They instrument crash reporting early. Discover issues before your users do.

“The apps we're most proud of aren't the ones with the most features — they're the ones where the shared codebase stayed clean for two years and adding a new platform took days, not months.”

If your team needs a senior MAUI engineer who's already made these architectural decisions in production apps, let's talk about what you're building.

.NET MAUIArchitectureMVVMCommunityToolkitPerformanceCode SharingCross-Platform
Alex M.
Alex M.
Senior .NET MAUI Developer · 7 Years Experience

Alex has architected and shipped 14 production MAUI and Xamarin apps across healthcare, logistics, and fintech. He contributes to the .NET MAUI open-source project on GitHub.