roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Prepare for Flutter interviews: Dart 3, widgets and rendering, layout, state libraries, navigation and native interop. Covers backends and Firebase, performance, testing and store release.
873 of 873 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 873 new. 0 cut, outside your plan.
Interviewing for a Flutter team, expect the framework to fill most of the loop; for other teams it comes up, if at all, as a few questions inside a broader round. A typical sequence is a screen on Dart and widget basics, a practical exercise (often a take-home that lists data from an API), one or two technical conversations and, from middle level up, a mobile design round on offline data, pagination and app structure. Native Android and iOS loops raise it when the team runs or is weighing a shared codebase, mostly as questions about what crossing to native code costs. The technical conversations run on the framework's own mechanics. Why does typed text jump to the wrong row when an item is removed from a list of stateful children, and what does a `ValueKey` change? Why does a `ListView` placed directly in a `Column` fail with *Vertical viewport was given unbounded height*, and what does that say about constraints passing down and sizes passing up? What breaks when a callback uses its `BuildContext` after an `await`? On the Dart side, expect the order in which a microtask and a future callback run, and why decoding a large JSON payload on the main isolate drops frames. Two candidates can propose the same fix and still land at different levels. Earlier levels name the widget or the fix. Later ones locate the cost: whether the UI thread or the raster thread missed the frame budget in a profile build, which rebuilds a `const` constructor or a narrower listener would have spared, what each platform-channel call pays to serialize its arguments, and when a feature is cheaper to write natively than to bridge.
The plan opens on Dart, but not all of it: only the language core that widget code is written in, from [null safety](/topics/lang-dart-null-safety) to the [records and patterns](/topics/lang-dart-records-patterns) that sealed state classes are later matched with. Asynchrony and the toolchain are held back for later. The next four modules are the framework seen from the screen. [How a widget lives](/topics/mob-flutter-widget-tree) and the [frame pipeline](/topics/mob-flutter-rendering) beneath it come first, because the widget, element and render-object trees are what later answers refer to: keys make sense once you know an element is matched by type and position, and layout errors make sense once you know who measures whom. [Box constraints](/topics/mob-flutter-layout-constraints) and [scrolling](/topics/mob-flutter-scrolling) apply that model, the visual layer dresses it, and motion closes the stretch: [animations](/topics/mob-flutter-animations) run on tickers the frame scheduler drives, so they read best after the pipeline. The plan picks Dart back up after the motion stretch, for [futures, streams and the event loop](/topics/lang-dart-futures-async) and [isolates](/topics/lang-dart-isolates), because the state stretch that follows is made of those types. A `FutureBuilder`, Riverpod's `AsyncValue` and a BLoC's stream of states are three wrappers around the same asynchrony. [Built-in reactivity](/topics/mob-flutter-state-management) leads the state stretch, so `setState` and `ChangeNotifier` are understood before the libraries that replace them, [Riverpod](/topics/mob-riverpod) and [BLoC](/topics/mob-bloc) among them. From there the plan widens to the app around the screens. Architecture shares a module with [routing](/topics/mob-flutter-navigation), because a redirect that checks the signed-in user is a structural decision as much as a navigational one. Data follows, from API clients and on-device storage to Firebase, and [native interop](/topics/mob-flutter-platform-interop) closes the stretch at the point where Flutter's own drawing ends, with web and desktop targets beside it. The last three modules belong to the working engineer. The Dart [toolchain](/topics/lang-dart-tooling) arrives after Riverpod and the JSON models have already leaned on `build_runner`, so the generator has examples waiting. [Jank and size tuning](/topics/mob-flutter-perf) reuses the frame pipeline and isolates from earlier, and testing and [store release](/topics/mob-flutter-release) end the plan at a signed build.
Native Android and iOS developers already hold the part of this plan many Flutter developers lack: they know what a platform channel lands in and what a store review rejects. Their gap is Dart and the drawing model, so the first two modules repay their time most. React developers find the declarative build method familiar and stumble on layout, where the parent's constraints, not the content, decide a widget's size. On a short runway, cut the state-library stretch by hand before touching any control. Most teams settle on one library, so study the one the posting names with the built-in reactivity beneath it, and leave the rest. For the remaining modules, let the page do the trimming: cut importance back to must know and pull level in to the seniority the posting asks for. Given months, set study order to by topics, because each stretch of this plan leans on the one before it. Check every performance answer on a real device in profile mode: a debug build runs without ahead-of-time compilation and with assertions on, so its frame times mislead. The plan treats native code as the far end of a channel: it teaches how a call crosses, not how to write the Kotlin or Swift that answers it, or the activity and view-controller lifecycles around that code. Those belong to the [Android Developer](/roadmaps/android) and [iOS Developer](/roadmaps/ios) roadmaps; take the one that matches the plugin you expect to write.
Interviewing for a Flutter team, expect the framework to fill most of the loop; for other teams it comes up, if at all, as a few questions inside a broader round. A typical sequence is a screen on Dart and widget basics, a practical exercise (often a take-home that lists data from an API), one or two technical conversations and, from middle level up, a mobile design round on offline data, pagination and app structure. Native Android and iOS loops raise it when the team runs or is weighing a shared codebase, mostly as questions about what crossing to native code costs.
The technical conversations run on the framework's own mechanics. Why does typed text jump to the wrong row when an item is removed from a list of stateful children, and what does a ValueKey change? Why does a ListView placed directly in a Column fail with Vertical viewport was given unbounded height, and what does that say about constraints passing down and sizes passing up? What breaks when a callback uses its BuildContext after an await? On the Dart side, expect the order in which a microtask and a future callback run, and why decoding a large JSON payload on the main isolate drops frames.
Two candidates can propose the same fix and still land at different levels. Earlier levels name the widget or the fix. Later ones locate the cost: whether the UI thread or the raster thread missed the frame budget in a profile build, which rebuilds a const constructor or a narrower listener would have spared, what each platform-channel call pays to serialize its arguments, and when a feature is cheaper to write natively than to bridge.
The plan opens on Dart, but not all of it: only the language core that widget code is written in, from null safety to the records and patterns that sealed state classes are later matched with. Asynchrony and the toolchain are held back for later.
The next four modules are the framework seen from the screen. How a widget lives and the frame pipeline beneath it come first, because the widget, element and render-object trees are what later answers refer to: keys make sense once you know an element is matched by type and position, and layout errors make sense once you know who measures whom. Box constraints and scrolling apply that model, the visual layer dresses it, and motion closes the stretch: animations run on tickers the frame scheduler drives, so they read best after the pipeline.
The plan picks Dart back up after the motion stretch, for futures, streams and the event loop and isolates, because the state stretch that follows is made of those types. A FutureBuilder, Riverpod's AsyncValue and a BLoC's stream of states are three wrappers around the same asynchrony. Built-in reactivity leads the state stretch, so setState and ChangeNotifier are understood before the libraries that replace them, Riverpod and BLoC among them.
From there the plan widens to the app around the screens. Architecture shares a module with routing, because a redirect that checks the signed-in user is a structural decision as much as a navigational one. Data follows, from API clients and on-device storage to Firebase, and native interop closes the stretch at the point where Flutter's own drawing ends, with web and desktop targets beside it.
The last three modules belong to the working engineer. The Dart toolchain arrives after Riverpod and the JSON models have already leaned on build_runner, so the generator has examples waiting. Jank and size tuning reuses the frame pipeline and isolates from earlier, and testing and store release end the plan at a signed build.
Native Android and iOS developers already hold the part of this plan many Flutter developers lack: they know what a platform channel lands in and what a store review rejects. Their gap is Dart and the drawing model, so the first two modules repay their time most. React developers find the declarative build method familiar and stumble on layout, where the parent's constraints, not the content, decide a widget's size.
On a short runway, cut the state-library stretch by hand before touching any control. Most teams settle on one library, so study the one the posting names with the built-in reactivity beneath it, and leave the rest. For the remaining modules, let the page do the trimming: cut importance back to must know and pull level in to the seniority the posting asks for. Given months, set study order to by topics, because each stretch of this plan leans on the one before it. Check every performance answer on a real device in profile mode: a debug build runs without ahead-of-time compilation and with assertions on, so its frame times mislead.
The plan treats native code as the far end of a channel: it teaches how a call crosses, not how to write the Kotlin or Swift that answers it, or the activity and view-controller lifecycles around that code. Those belong to the Android Developer and iOS Developer roadmaps; take the one that matches the plugin you expect to write.