Learn .NET MAUI with production standards

I teach .NET MAUI the way it’s used in real products: correct structure, safe rollout, and controlled migration from Xamarin.Forms.

My courses are not just pre-recorded videos. Every student gets access to me directly for 1:1 help on real code.

Course 1: .NET MAUI Foundations

Who this is for
Developers who are new to .NET MAUI, or coming from Xamarin, and want to build an actual application the right way from day one.

What you’ll learn

• Create a MAUI app from scratch.
• Project structure and architecture
• Build modern and performant UI.
• Get familiar with MVVM pattern, data bindings, commands, and observable properties.
• Navigate with AppShell.
• Show and interact with lists via CollectionView & DataTemplates.
• Learn about mobile app lifecycle
• Debug common mobile issues.
• DI, handlers, platform specifics.

You’ll build - A simple, data-driven cross-platform app

• Home list (CollectionView)
• Add/Edit page (Entry/Editor, validation)
• Navigation
• MVVM

Included

• Video lessons
• 3× 45-min 1:1 session
• Example patterns and code structure you can reuse
• Direct access to ask questions

Course 2: .NET MAUI Production-Ready

Who this is for

Developers who understand the MAUI basics (XAML, MVVM, and Shell navigation) but need the professional playbook to build, scale, and ship a maintainable, high-quality application.

What you’ll learn

• Spin up a clean solution that’s production-ready.
• Structure an app with clear layers (e.g., Core, Infrastructure, UI) that won't collapse at scale.
• Master Dependency Injection: services, repositories, constructor injection, and service lifetimes.
• Go native safely with Handlers: mapping properties/events, platform tweaks, and lifecycle/disposal.
• Integrate platform features (camera, permissions, geolocation) without crashing on resume or failure.
• Understand the advanced app lifecycle, startup performance, and optimization (Trimming/AOT basics).
• Ship confidently with build flavors, environment-specific settings, and crash/analytics wiring.

You’ll build

A production-ready solution "scaffolding" you can reuse for all future projects. This includes the complete architecture, DI, configuration, logging, and a pre-release checklist.

Included

• Video lessons
• Reusable production-ready solution template
• 5× 45-min 1:1 session
• 3 months consultation (direct access to ask questions)

Course 3: Migration from Xamarin.Forms to .NET MAUI (Advanced)

Module 1. Xamarin.Forms vs .NET MAUI: What Actually Changed

• Project structure: multi-project vs single project
• Startup / app lifecycle: old App.xaml.cs vs. MAUI builder and DI
• Renderers vs Handlers model
• Navigation differences and where state actually lives now
• Dependency injection and configuration in MAUI vs “static singletons everywhere” in older Xamarin code
• How these differences impact maintainability, performance, and crash surfaces

Goal: You understand MAUI as its own platform, not “Xamarin with new branding.”

Module 2. Planning the Migration Before You Touch Code

• Identifying critical surfaces (what users touch every day vs what can wait)
• Choosing the first slice to migrate (and why “start from Settings page” is usually wrong)
• Risk mapping: UI-heavy vs native-integration-heavy features
• How to decide between phased rollout vs version cutoff
• How to communicate the plan internally (leadership, QA, support)

Goal: You have a migration plan you can defend to your team.

Module 3. Why You Should Not Use the “Upgrade Tool”

• What the upgrade tool actually does and why it looks attractive
• Why dragging your entire codebase forward at once imports all the old problems (invisible memory leaks, old navigation patterns, old renderer assumptions)
• Why “it compiles” is not the same as “it’s safe to ship”
• Real risks: performance regressions, startup slowdowns, crash spikes
• When the tool can be useful (yes, there are limited cases) — and how to treat it if you do run it

Goal: You stop thinking in terms of “convert the app,” and start thinking “stabilize the app while it evolves.”

Module 4. Clean .NET MAUI Foundation

• Creating a brand new .NET MAUI project as the migration target
• Setting up DI, configuration, logging, and environment handling properly from day one
• Project structure and folder layout for long-term sanity (not demo templates)
• Adding only the NuGet packages you actually need — how to choose and validate each one
• Setting up a controlled place for platform-specific code

Goal: You have a high-quality MAUI base that you’re not embarrassed to keep growing.

Module 5. Bringing Code Over Incrementally (Not “Big Bang”)

• How to copy a screen into MAUI, one feature at a time
• Porting XAML and what usually breaks
• Adapting navigation calls
• Handling data layer / services reuse (what can move as-is, what needs rewriting)
• Validating each migrated piece on device before you move on

Goal: You learn how to migrate in slices and get working, testable app growth every step instead of a 6-month rewrite with no shippable build.

Module 6. Handlers vs Renderers

• What custom renderers did in Xamarin.Forms
• How handlers work in .NET MAUI (and why they’re lighter/faster)
• Mapping: “I have a custom renderer for Entry in Xamarin — what does that look like in MAUI?”
• When you can translate logic directly, and when you need to rethink it
• Platform-specific tweaks (iOS/Android differences you must retest)
• Common pitfalls during this step (lifecycle assumptions, disposal/cleanup behavior)

Goal: You can successfully migrate custom UI without breaking platform behavior.

Module 7. App Lifecycle and Navigation Differences

• Application startup in MAUI vs MainActivity / AppDelegate patterns in older solutions
• State management and when to persist vs when to rebuild
• Navigation stacks and back behavior differences (and how that affects deep links / modals / shell)
• Handling resume/suspend scenarios in MAUI safely

Goal: Your migrated screens behave like a real app, not “it works until you background it.”

Module 8. Performance & Startup Health

• Startup cost in Xamarin.Forms vs MAUI
• Trimming / AOT basics for MAUI and what it actually buys you
• Avoiding “everything registers on startup” anti-patterns
• Lazy-loading heavy services, expensive pages, or native bindings
• Keeping startup time acceptable across older Android devices (not just your dev phone)

Goal: You don’t ship a migration that feels slower than what users had before.

Module 9. Stability and Crash Control

• Crash rate as a release gate: how to define “safe enough”
• Monitoring per-version crash impact
• How to set up a “kill switch” / feature flag to turn off risky functionality in production without waiting for App Store review
• How to safely expose new MAUI code to a subset of users first
• Handling platform differences (Android-only issue vs global rollback)

Goal: You build in control, not just code. You can respond if something goes wrong.

Module 10. Rollout Strategy

• How to introduce the MAUI version without a “big announcement”
• Phasing: which user groups or regions should see it first
• How to keep the old Xamarin app healthy while MAUI grows
• Communicating change internally to support / product / leadership so nobody panics
• When to fully cut over

Goal: You know how to ship the migration without drama, and without surprising people inside or outside the team.

Module 11. Final Sign-Off Checklist

This is the checklist you will give to your team before a release.

It covers:

• Are we shipping from a clean MAUI base? Yes/No
• Has this feature been migrated + tested on both platforms?
• Do we have a rollback/disable path if something goes wrong?
• Is performance at least on par with the previous app?
• Is crash behavior acceptable on staging devices we care about (not just simulator)?

Goal: You have something concrete to run before pressing “Submit for Review.”

The goal
Deliver your .NET MAUI migration in a controlled, testable way while continuing to ship features and protecting production stability.

Included

• Video lessons
• 7× 45-min 1:1 session
• A step-by-step migration framework you can apply to your existing app
• A documented rollout plan you can share with your lead / manager to align expectations
• A stability and readiness checklist for release approval
• 3 months consultation (direct access to ask questions)

1:1 Coding Sessions (Included for Students)

This is what makes these courses different from “watch some videos.”

When you enroll, you get access to live 1-on-1 time with me.

How it works

I am offering private mentorship tied to the course material: you build, I guide live, review implementation, and unblock issues (architecture, handlers, migration steps, release readiness).

Need more than what’s included?
Book additional sessions as needed (€65/hour or €180 / 3-hour pack).

Ready to level up?

Pick your path, tell me where you are, and I’ll reply with the plan and schedule.