Step 1 • Before You Start
Prerequisites — OOP, Mobile Concepts, and Dart Intro beginner Flutter uses Dart — a language you likely don't know yet. Before diving in, be comfortable with OOP fundamentals: classes, inheritance, interfaces, constructors, and access modifiers (Flutter uses these heavily). Understand what a mobile SDK is, the difference between native (platform-specific code) and cross-platform (one codebase, multiple platforms), and why Flutter differs from React Native (compiles to native ARM code vs bridges to JS). No prior mobile experience is required, but understanding how apps are distributed (App Store, Play Store review process) helps set expectations.
4h Step 2 • Dart
Dart Fundamentals — Syntax, Types, and Null Safety beginner Dart is strongly typed with sound null safety (no null pointer exceptions if you use it correctly). Learn: variable declarations (var, final, const — prefer const for compile-time constants), built-in types (int, double, String, bool, List, Map, Set), nullable vs non-nullable types (String? is nullable, String is not), the ! null assertion operator (use sparingly), the ?? null-coalescing operator, late variables, control flow (if/else, for, while, do-while, switch), functions (positional, named, optional parameters), arrow functions (=>), and string interpolation ($variable and ${expression}).
6h Step 3 • Dart
Dart Advanced — Classes, async/await, and Streams intermediate Dart classes are central to Flutter. Learn: constructors (named constructors, factory constructors, const constructors), mixins (add capabilities without inheritance — Flutter uses them extensively), abstract classes and interfaces (Dart interfaces are implicit — any class can be used as one), extension methods (add methods to existing types), generics, and the cascade operator (..). Async: Future<T> (a single async value), async/await, then()/catchError(), Future.wait() (parallel). Stream<T> (multiple async values over time) — listen(), StreamController, StreamBuilder widget. Error handling with try/catch in async.
7h Step 4 • Setup
Flutter SDK, Toolchain, and First App beginner Install the Flutter SDK (fvm for version management), run flutter doctor to verify your setup, configure Android Studio (Android emulator) and/or Xcode (iOS Simulator on macOS). Understand the project structure — lib/main.dart (entry point), pubspec.yaml (dependencies), android/ and ios/ (platform-specific shells). Run flutter run (hot reload ⚡ on save — the killer DX feature), flutter build apk/ios/web. Understand hot reload vs hot restart. Run flutter pub add package_name to add dependencies. Use flutter analyze and flutter test in CI.
4h Step 5 • Foundations
Widgets — Everything is a Widget beginner Flutter's UI is entirely widget trees. Two base types: StatelessWidget (immutable, renders once based on props) and StatefulWidget (has State<T> that can change with setState()). Learn the widget lifecycle: createState, initState, build, setState, dispose. Essential widgets: Text, Image, Icon, Container, Padding, Center, SizedBox, Card, Scaffold (the page structure — AppBar, body, FAB, drawer, bottomNavigationBar), ListView, GridView, Column, Row, Stack, Expanded, Flexible. Keys matter when reordering lists — use ValueKey or ObjectKey to preserve state.
8h Step 6 • Foundations
Layouts — Row, Column, Stack, and Responsive Design intermediate Flutter layout uses a constraints model — parents constrain children, children report their size. Core layout widgets: Row and Column (flex containers — Expanded gives a child all remaining space, Flexible gives it a flex factor, mainAxisAlignment and crossAxisAlignment control positioning), Stack (absolute positioning with Positioned — z-index layering), Wrap (wraps children to next line when out of space), CustomScrollView + Slivers for advanced scrolling (SliverAppBar, SliverList). Responsive design: MediaQuery for screen dimensions, LayoutBuilder for parent constraints, flutter_adaptive_scaffold for breakpoints.
7h Step 7 • State Management
State Management with Riverpod intermediate setState() works for local state but doesn't scale across screens. Riverpod is the recommended state management solution — compile-safe, testable, no BuildContext required for reading state. Learn: Provider (synchronous immutable state), StateProvider (simple mutable state), StateNotifierProvider (complex state with a StateNotifier class), FutureProvider (async data), StreamProvider (stream data), WidgetRef.watch (rebuild on change) vs WidgetRef.read (one-time read in event handlers), provider scoping, and the code generation approach (Riverpod Generator). Provider and Bloc are alternatives.
8h Step 8 • Navigation
Navigation with GoRouter intermediate Flutter has two navigation APIs. Navigator 1.0 (imperative — push, pop) is simple for basic apps. Navigator 2.0 (declarative — route stack as state) is complex but powerful. GoRouter wraps Navigator 2.0 with a URL-based, declarative API — similar to web routing. Learn: GoRouter setup, path-based routes (/home, /recipes/:id), named routes, sub-routes (nesting), ShellRoute for persistent navigation (bottom nav bar stays while content changes), redirects for auth guards, query parameters, and deep linking from push notifications or URLs. GoRouter plays well with Riverpod for auth-aware redirects.
6h Step 9 • Data Layer
HTTP, APIs, and JSON Serialization intermediate Connect Flutter to real data. The dio package is more powerful than the built-in http — interceptors, form data, cancellation, retry. Learn: making GET/POST/PUT/DELETE requests, handling responses and errors, JSON serialization (jsonDecode is manual — prefer json_serializable with build_runner for auto-generated fromJson/toJson), the Freezed package for immutable model classes with copyWith, and the Repository pattern (abstract data sources behind an interface). Use Riverpod's FutureProvider + AsyncValue for loading/error/data states. Add retrofit for type-safe API clients.
7h Step 10 • Data Layer
Local Storage — Preferences, Hive, and SQLite intermediate Persist data locally across app restarts. SharedPreferences — key-value store for small amounts of simple data (user settings, auth tokens, onboarding flags). Hive — a fast, pure-Dart NoSQL database using boxes — great for storing lists of objects (no SQL needed). Isar — Hive's successor, faster and with a query language. Drift (formerly moor) — SQLite wrapper with type-safe queries generated from table definitions (like Dart sqlc). flutter_secure_storage for sensitive data (passwords, tokens) — uses Keychain on iOS, Keystore on Android. Choose based on complexity: SharedPreferences < Hive < Drift.
6h Step 11 • UI Polish
Animations — Implicit, Explicit, and Hero intermediate Flutter animations are smooth and powerful. Three levels: Implicit animations (easiest — AnimatedContainer, AnimatedOpacity, AnimatedSwitcher, AnimatedCrossFade — set a property, Flutter tweens to it automatically), Explicit animations (AnimationController + Tween + AnimatedBuilder — full control over timing and curves), and Custom painters (draw frame-by-frame with CustomPaint + Canvas). Hero transitions animate a widget between screens. Rive and Lottie for designer-created vector animations imported as assets. Understand the ticker provider (SingleTickerProviderStateMixin) and why animations must be disposed.
6h Step 12 • Backend Integration
Firebase Integration — Auth, Firestore, and Notifications intermediate Firebase is the fastest way to add a backend to Flutter. FlutterFire is the official plugin suite. Learn: Firebase Auth (email/password, Google Sign-In, Apple Sign-In — required for App Store), Firestore (NoSQL real-time database — listen to document changes as Streams, offline persistence), Firebase Storage (file uploads — images, documents), Firebase Messaging (FCM push notifications — foreground, background, and terminated states), Firebase Crashlytics (crash reporting — replace print with FirebaseCrashlytics.instance.log), and Remote Config (feature flags without app updates).
8h Step 13 • Advanced
Analytics and Crash Reporting intermediate Understanding user behaviour is essential for product decisions. Firebase Analytics: automatic screen tracking, custom events (FirebaseAnalytics.instance.logEvent(name: 'add_to_cart', parameters: {...})), user properties, conversion funnels. Firebase Crashlytics: non-fatal error reporting (FirebaseCrashlytics.instance.recordError(e, stack)), custom keys for debugging context. Mixpanel or Amplitude for product analytics — identify users, track retention, build cohorts. Use an analytics abstraction layer so you can swap providers without touching every screen. Privacy: collect only what you need, respect GDPR/CCPA (consent management), anonymise user IDs. Sentry for Flutter as an alternative crash reporter with fuller stack traces.
4h Step 14 • Testing
Testing — Widget Tests and Integration Tests intermediate Flutter testing has three levels. Unit tests (test package — test Dart logic, Riverpod providers, repositories without UI). Widget tests (flutter_test — mount a widget in a test environment with WidgetTester, interact with find.byType/byKey, tap/enterText/pump, verify rendering). Integration tests (integration_test package — run on a real device or emulator, test full user flows). Mockito or Mocktail for mocking services. Golden tests (matchesGoldenFile) for screenshot regression testing. Run all tests on CI with flutter test and flutter test integration_test.
7h Step 15 • Native Integration
Platform Channels and Native Integration advanced Flutter apps sometimes need platform APIs not covered by existing plugins. Platform Channels bridge Dart and native code (MethodChannel for one-time calls, EventChannel for streams). Common needs: camera (camera plugin), location (geolocator), biometrics (local_auth), push notification deep links, in-app purchases (in_app_purchase), and background processing (workmanager). Before writing native code, check pub.dev — someone has likely already built a plugin. When you must write native code, understand the Flutter embedding API for Android (Kotlin/Java) and iOS (Swift/Objective-C).
6h Step 16 • Production
CI/CD, Flavors, and App Store Deployment advanced Shipping a Flutter app involves more than writing code. App flavors (flutter --flavor dev/staging/prod) for different environments (API URLs, Firebase projects, app icons, bundle IDs). Codemagic or Fastlane for CI/CD — automatically run tests, build signed APK/IPA, and submit to TestFlight and Google Play Internal Track on every merge to main. Code signing — Apple certificates and provisioning profiles, Android keystore. App Store submission requirements (privacy manifest in iOS 17+, screenshots, review guidelines). Crashlytics for post-launch crash monitoring. Over-the-Air updates with Shorebird (code push for Dart code changes without store review).
8h Step 17 • advanced
CI/CD & App Distribution advanced Automate Flutter build and release pipelines. Run flutter test, flutter analyze, and dart format --check in CI. Build IPA (iOS) and APK/AAB (Android) artifacts in GitHub Actions, Codemagic, or Bitrise. Use Fastlane (match for iOS signing, supply for Play Store uploads) for automated submissions. Distribute test builds with Firebase App Distribution or TestFlight. Manage signing certificates and keystores securely as CI secrets.
8h 