Flutter Reference

An in-depth Flutter reference built from production experience at 5M+ users — definitions, head-to-head comparisons, curated package directories, and architecture guides.

Glossary

State Management

BLoC — BLoC (Business Logic Component) is a reactive state management pattern for Flutter that uses streams to separate business logic from UI. Learn how it works and when to use it.
Cubit — Cubit is a lightweight variant of the BLoC pattern that replaces events with direct method calls. Simpler than BLoC, but the same testability and reactive model.
Riverpod — Riverpod is a reactive caching and state management framework for Flutter that improves on Provider with compile-time safety, no BuildContext dependency, and auto-dispose.
GetX — GetX is an all-in-one Flutter framework providing state management, dependency injection, route management, and utilities. Popular for rapid prototyping, controversial for production.
RxDart — RxDart extends Dart streams with powerful operators like debounce, throttle, switchMap, and combineLatest. Learn how it powers complex reactive flows in Flutter.

Architecture

Clean Architecture — Clean Architecture for Flutter separates an app into layers — presentation, domain, and data — so business logic is independent of frameworks, databases, and UI. Learn the pattern and its benefits.
Dependency Injection — Dependency injection in Flutter decouples object creation from usage. Learn how get_it, Provider, and injectable make your code testable, modular, and maintainable.
Modular Architecture — Modular architecture in Flutter splits the app into independent feature modules, each owning its own UI, logic, and data. Scales to 50+ modules at 5M-user scale.
Reactive Programming — Reactive programming in Flutter uses streams and observables to propagate change automatically. Learn how RxDart, BLoC, and StreamBuilder power reactive UIs.
Repository Pattern — The repository pattern abstracts data sources behind a single interface, so the app doesn't know or care where data comes from. Learn how to implement it in Flutter.
Either<Failure, T> Pattern — Either<Failure, T> is a functional error handling pattern that represents success (Right) or failure (Left) as a value — not an exception. Learn how it works and why it prevents crashes.

Data & Connectivity

Offline-First — Offline-first is a mobile architecture where the app reads and writes against a local database by default, treating the network as a background sync concern — not a prerequisite for UI.
Local-First — Local-first architecture makes the device's local database the authoritative source of truth. The server syncs in the background, but never blocks reads or writes.
PowerSync — PowerSync is a sync engine that keeps a local SQLite database in sync with a Postgres backend, enabling offline-first Flutter apps with automatic conflict resolution.
Drift — Drift is a reactive SQLite ORM for Flutter with type-safe queries, code generation, and stream-based reactive queries. Learn how it powers offline-first apps.

CI/CD

Trunk-Based Development — Trunk-based development is a Git strategy where all developers merge to a single shared branch (master/main) frequently, keeping branches short-lived. It enables continuous integration and fast release cycles.
Feature Flags — Feature flags let you toggle functionality on or off remotely without a new app release. Learn how to decouple deploy from release in Flutter with GrowthBook, Firebase, and more.

Build & Release

Build Flavors — Build flavors in Flutter let you run multiple environments (dev, staging, production) from one codebase with different bundle IDs, icons, and configuration. Learn the full setup.

Quality

Crash-Free Rate — Crash-free rate is the percentage of sessions that complete without a crash. Learn what target to aim for (99.9%+), how to measure it, and how to maintain it at scale.
Sentry for Flutter — Sentry is a crash monitoring and performance tracing platform for Flutter apps. Learn how it captures Dart and native crashes, performance traces, and session replays.

State Management Comparisons

BLoC vs Riverpod — BLoC vs Riverpod for Flutter: a production-scale comparison of boilerplate, testing, debugging, and team adoption from a 5M-user codebase.
BLoC vs Cubit — BLoC vs Cubit: when the event-class ceremony is worth it and when Cubit's simpler API is the right call — from a team that runs both at 5M-user scale.
Riverpod vs Provider — Riverpod vs Provider: compile-time safety, no BuildContext dependency, and testability — why Riverpod replaced Provider in modern Flutter codebases.
BLoC vs GetX — BLoC vs GetX: architecture, testability, dependencies, and long-term maintainability — why production teams pick BLoC over GetX's all-in-one toolkit.
Riverpod vs BLoC — Riverpod vs BLoC performance: rebuild granularity, stream overhead, memory, and large-list scrolling — measured from a 5M-user Flutter app.

Data & Storage Comparisons

Drift vs Hive — Drift vs Hive: relational SQL with reactive queries vs key-value NoSQL — which to pick for offline-first Flutter, from a PowerSync+Drift production codebase.
Drift vs sqflite — Drift vs sqflite: type safety, reactive queries, migrations, and boilerplate — why production Flutter teams layer Drift over raw sqflite.

Data & Sync Comparisons

PowerSync vs Supabase — PowerSync vs Supabase: local-first SQLite sync vs a full Postgres backend — how they fit together in a 5M-user offline-first Flutter app.

Cross-Platform Comparisons

Flutter vs React Native — Flutter vs React Native: rendering, performance, talent, ecosystem, and long-term maintenance — from a senior mobile engineer leading a 5M-user Flutter app.
Flutter vs Kotlin Multiplatform — Flutter vs Kotlin Multiplatform: shared UI vs shared logic, native interop, and when KMP's business-logic-only model beats Flutter's full UI sharing.

Architecture Comparisons

Clean Architecture vs MVVM — Clean Architecture vs MVVM for Flutter: layering, testability, boilerplate, and which scales at 50+ modules — from a production squad lead.
Offline-First vs Local-First — Offline-first vs local-first: cloud-as-source-of-truth vs device-as-source-of-truth — the architectural decision that shapes your entire data layer.

CI/CD Comparisons

Fastlane vs Codemagic — Fastlane vs Codemagic for Flutter: local release automation vs managed CI — what a GitHub-Actions-native team picked and why.
GitHub Actions vs Codemagic — GitHub Actions vs Codemagic for Flutter: cost, iOS signing, control, and why a 5M-user app team standardized on GitHub Actions + Fastlane.

Growth Comparisons

Feature Flags vs A/B Testing — Feature flags vs A/B testing: release governance vs experimentation — what each is for and why conflating them causes bad decisions.

Testing Comparisons

Patrol vs Maestro — Patrol vs Maestro for Flutter integration tests: Dart-native vs YAML-based, custom finder vs accessibility, and which fits a Flutter-first team.

Networking Comparisons

Dio vs http — Dio vs http for Flutter: interceptors, cancellation, FormData, retries, and when the standard http package is enough — from a production networking layer.

Code Generation Comparisons

Freezed vs json_serializable — Freezed vs json_serializable: sealed unions, copyWith, equality, immutability — when Freezed's union modeling wins over plain JSON mapping.

Monetization Comparisons

RevenueCat vs Stripe — RevenueCat vs Stripe for Flutter: App Store/Play subscriptions vs custom payments — what a 5M-user app uses and why you likely need both.

Quality Comparisons

Sentry vs Firebase Crashlytics — Sentry vs Firebase Crashlytics for Flutter: grouping, release tracking, performance, source maps, and why a 5M-user app standardized on Sentry.

Best Flutter Packages

Architecture Guides

Flutter Clean Architecture: A Complete Guide — A practical Flutter Clean Architecture guide — layer separation, dependency rule, folder structure, and a full Dart example from a 5M-user codebase.
Flutter Feature-First Modular Architecture — How to structure a Flutter app feature-first with modular packages. Folder structure, shared kernels, and boundary rules from a 50+ module production codebase.
How to Build Offline-First Flutter Apps — A how-to guide for offline-first Flutter apps: local database as source of truth, background sync, conflict resolution, and a Dart template using PowerSync + Drift.
Flutter Repository Pattern: A Practical Guide — A practical guide to the repository pattern in Flutter — abstract contracts, multiple data sources, cache strategy, and a full Dart example with offline fallback.
Flutter Dependency Injection: Provider, get_it, injectable — A comparison and practical guide to Flutter DI: Provider vs. get_it vs. injectable. Which to choose, how to wire them up, and production patterns from a 50+ module app.
Flutter BLoC Architecture: Structuring Events, States & Logic — A guide to structuring Flutter BLoC architecture — events, states, when to use BLoC vs. Cubit, stream transformers, and a full Dart example with testing.
Flutter Error Handling: Either<Failure, T> and Beyond — A guide to Flutter error handling with Either<Failure, T> — domain failures, Result types, async error zones, and crash reporting from a 99.9% crash-free codebase.
Flutter Testing Strategy: Unit, Widget & Integration Tests — A practical Flutter testing strategy — the test pyramid, what to test at each layer, golden tests, integration tests, and CI patterns from a production codebase.
Flutter Build & Release Pipeline: Flavors, CI/CD, Stores — A reference guide to Flutter build and release — flavors, environment configs, CI/CD pipelines, and store deployment from a team that ships weekly at 5M+ users.
Flutter Performance Architecture: Profiling & Optimization — A guide to Flutter performance architecture — jank detection, build optimization, memory profiling, and the optimization patterns that keep a 5M-user app at 60fps.

Available for hire. Abdelrahman Saed is a Senior Mobile Engineer (Flutter) — open to full-time, fractional, contract, or advisory work. Hire me →

Book a 20-minute call · Download the CV (PDF) · See how I work