Flutter Mastery Path¶
Flutter builds apps for Android, iOS, the web, Windows, macOS and Linux from one Dart codebase,
and it does so differently from most UI toolkits: instead of wrapping each platform's native
buttons and lists, it draws every pixel itself, from a tree of small immutable widgets rebuilt
whenever something changes. That design is why Flutter apps look identical everywhere and
animate smoothly — and it's also why Flutter's problems are recognisable: an overflow stripe
because a child ignored its constraints, a text field that empties itself when it's wrapped in a
Padding, a list whose ticks stay put when the rows move, a spinner that freezes while JSON is
parsed, a screen that rebuilds sixty times a second for no reason. This course teaches you to
build Flutter apps and to understand the framework well enough to avoid all of those.
Level 1 starts from the engine and the widget tree: setup, composition, the constraints
model, stateful widgets and their lifecycle, forms, lists and keys, Material 3 theming and
assets — ending with a tip splitter covered by widget tests. Level 2 builds real apps:
navigation and go_router, InheritedWidget, Provider and Riverpod with measured rebuilds,
async UI, a typed HTTP client, local persistence, and unit, widget and golden tests — ending with
a reading-list app. Level 3 goes underneath and outward: elements and keys, implicit and
explicit animations, CustomPainter, responsive layouts, platform channels, isolates, Bloc,
accessibility and localization, integration tests — ending with an offline-first habit tracker
with a persisted sync queue. Level 4 is production: the rendering pipeline and a custom
RenderObject, performance, architecture and dependency injection, configuration and flavors, CI,
store publishing, the web and desktop, plugins and dart:ffi, upgrades — and a production-ready
expense tracker capstone.
Every lesson has a How It Actually Works section — how setState turns into a rebuild of
exactly the dirty elements, why a key moves state with a row, how a FadeTransition animates
without rebuilding anything, what bytes a platform channel really sends, how a router derives a
whole page stack from one URL.
Run, not imagined
Code, commands, test output and error messages in this course come from real runs on
Flutter 3.44.8 (stable) with Dart 3.12.2, using go_router 18.0.2,
flutter_riverpod 3.4.3, provider 6.1.5+1, flutter_bloc 9.1.1, http 1.6.0,
shared_preferences 2.5.6 and intl 0.20.2. Most examples are verified as widget tests,
which render real widgets headlessly. Several lessons show first attempts that failed — a
setState that returned a Future, a semantics label without a text direction, a format
check that failed 57 files — because you'll meet those too. The machine used could build for
the web but not for Android (SDK licenses not accepted), iOS or macOS (no Xcode), and had no
device attached; lessons that involve devices, native code or store accounts say exactly what
was and wasn't run. Timings and sizes are one machine's results, not benchmarks.
How the program is organized¶
| Level | Focus | Modules |
|---|---|---|
| Level 1 · Entry | The engine and widgets, project setup, composition, constraints and layout, stateful widgets, forms, lists and keys, theming, assets | 9 topics + 1 project (a tip splitter with widget tests) |
| Level 2 · Intermediate | Navigator and go_router, InheritedWidget, Provider, Riverpod, async UI, HTTP and JSON, persistence, unit/widget/golden testing | 9 topics + 1 project (a reading-list app) |
| Level 3 · Advanced | Elements and keys, animations, CustomPainter, responsive layouts, platform channels, isolates, Bloc, accessibility and i18n, integration tests | 9 topics + 1 project (an offline-first habit tracker) |
| Level 4 · Master | Rendering pipeline, performance, architecture and DI, flavors and config, CI, publishing, web and desktop, plugins and FFI, upgrades | 9 topics + 1 capstone (a production-ready expense tracker) |
How to use this site¶
- Know your Dart first. Flutter code is Dart: classes, null safety,
async/await,Futures andStreams, records and pattern matching. If those are unfamiliar, start with Dart Mastery Path. - Run the tests, not just the app. Almost every lesson's code comes with a widget test that prints what happened. You can run them with only the Flutter SDK — no phone, emulator or simulator — and compare your output with the lesson's.
- Count rebuilds when something is slow or strange. Several lessons add a build counter to show exactly which widgets rebuilt; it's the quickest way to understand Flutter's behaviour.
- Related courses. For the native side of platform channels, see Kotlin Mastery Path and Swift Mastery Path; for the APIs your app calls, REST API Mastery Path; for CI, GitHub & Git Mastery Path; for a web-first alternative, React Mastery Path.
- Do the Exercise at the end of each lesson; the module-10 projects build on them.
Start here → Level 1 · Entry
🎥 Prefer video? Watch the Mastery Path video series on YouTube — Shorts and full walkthroughs of lessons across the series.
More from the Mastery Path series¶
Free, structured, module-wise training across 80 other languages, platforms and disciplines:
Languages
Web Frameworks
Mobile
Testing & QA
Security
Cloud Platforms
Data & Analytics
AI / ML / LLM
Embedded Systems
Leadership & Management
Professional Skills
Careers & Interviews
Process & APIs
Infrastructure & Ops