Question 1

How do you prepare for a rapid-fire round?

Accepted Answer

The most important thing is rehearsing out loud — what you know in your head comes out differently once it becomes speech. My method: write a three-part answer (answer, why, example) for each of 15-20 core concepts and time yourself to fit 30 seconds. Second: identify which questions fall into what I genuinely do not know, and prepare an honest formulation in advance so I do not improvise. Third: take the examples from my own project, because a textbook example collapses under a follow-up while your own experience only gets stronger the deeper it goes.

Question 2

What do you do when a question you cannot answer comes up?

Accepted Answer

I say so honestly and pair it with reasoning: "I do not know that specific detail, but my expectation would be..." and then show how I would think it through. That gives two things at once: honesty and a view of how I approach problems. The risk of inventing is disproportionate: interviewers almost always sense it, and afterwards they doubt the answers you got right too — one fabrication taints the whole interview. I would add that missing a few out of fifteen is entirely normal; nobody expects fifteen out of fifteen.

Question 3

What is the difference between hot reload and hot restart?

Accepted Answer

Hot reload injects changed code into the running app and keeps state — you stay wherever you were on screen, which is ideal for iterating on UI. Hot restart starts the app over and loses state, but reloads all the code in exchange. The practical split: reload is enough for changes inside build; changes to main(), globals, initialisation logic in initState, or the shape of an enum or class need a restart. One trap worth adding: if a screen behaves oddly after a reload, restart before investigating — the problem is often stale state rather than your code.

Question 4

How do you handle the shift when a deep question follows the rapid-fire round?

Accepted Answer

Recognising that the register changed is the point: brevity was a virtue in the rapid-fire round, structure is what the deep question wants. I make the transition explicit — instead of starting to talk immediately I take a few seconds and state the skeleton of the answer: "I would split this into three parts: the mechanism, the practical consequence, and when it does not apply." That buys me thinking time and shows the interviewer where I am heading. The failure mode is staying in rapid-fire rhythm and answering a deep question in two sentences — it reads as not knowing the topic, when in fact you simply did not change gear.

Question	20-30 second answer
Stateless vs Stateful?	Stateless holds no mutable internal state. Widgets are immutable, so mutable state lives in a separate `State` object that survives rebuilds — which is why controllers go there.
What does `setState` do?	Runs the callback synchronously and marks the element dirty; the rebuild happens next frame. Which is why awaiting inside it is pointless.
What are the three trees?	Widget (configuration, cheap), element (the live instance holding state), render (measure and paint). Diffing happens on the element tree.
What does `const` buy you?	The widget is created at compile time and canonicalised, recognised as the same object on rebuild, so its whole subtree is skipped.
When do you need a Key?	In a list of same-typed items that can reorder and hold state. Without it matching is positional and state lands on the wrong item.
The layout rule?	Constraints go down, sizes go up, the parent sets position. Which is why a child cannot know its parent’s size.
Expanded vs Flexible?	Expanded forces the child to fill the space (tight); Flexible lets it take less (loose). Expanded is a Flexible with a tight fit.
What is an InheritedWidget?	The mechanism for passing data down the tree. `of(context)` both finds and subscribes, so only dependants rebuild when it changes. Provider is built on it.
What is a BuildContext?	The widget’s position in the element tree. Being a position is what lets you look upward — and a wrong-level context is what produces "No Scaffold found".
watch vs read?	watch subscribes and triggers rebuilds, read does not. The rule: watch in build, read in callbacks.
Future vs Stream?	A Future is a single result, a Stream a sequence of events. A request is a Future; live updates are a Stream.
What is an isolate for?	Moving heavy synchronous computation off the UI thread. Memory is not shared and communication is by message, so there are no race conditions.
UI vs raster thread?	The UI thread runs Dart (build, layout); the raster thread paints via the GPU. Which one janks determines the fix.
The frame budget?	About 16 ms at 60 fps. Exceed it and a frame drops, which the user sees as jank.
What does a widget test not need?	A real device. Which is why it runs in seconds and can gate every PR in CI.
The pumpAndSettle trap?	With an endless animation it never returns and the test times out. Those screens need an explicit `pump(Duration)`.
Hot reload vs hot restart?	Hot reload swaps code and keeps state. Hot restart starts the app over and loses state. Changes to `main()` or globals need a restart.
Why profile mode?	For measuring performance. Debug is unoptimised and release has profiling disabled.

Rapid-fire Flutter questions

📚 Sources and documentation