Top 30 Intermediate Flutter & Dart Interview Questions and Answers

30 questions. Pick an answer, or open “Show the answer” to read it.

Answers are graded in your browser. Nothing is saved, and no XP or streak is earned here. The app keeps score.

1. Question 1 of 30

   When accessing a property on a nullable object in Dart, what is the fundamental difference between using ?. and !?

   • aBoth operators avoid runtime errors, but ?. is preferred for chained property access.
   • b! returns null on a null receiver, whereas ?. throws a runtime null assertion error.
   • c?. evaluates to null when the receiver is null, while ! casts to non-nullable and may throw at runtime.
   • d?. provides a default value if the object is null, while ! enforces compile-time null checks.
   Show the answer

   Answer: c · ?. evaluates to null when the receiver is null, while ! casts to non-nullable and may throw at runtime.

   The null-aware operator ?. short-circuits and yields null if the receiver is null, whereas ! forcibly casts away nullability and throws a runtime exception if the value is actually null. Option D is wrong because it confuses ?. with the ?? default-value operator and incorrectly suggests ! is compile-time safe.

   Read the full bite: Describe Dart's null-aware ?. and null assertion ! operators

2. Question 2 of 30

   A class declares late final UserService repo and assigns it in initState. What happens if repo is read in build before that assignment?

   • aA LateInitializationError is thrown at the point of access
   • bThe compiler reports a definite-assignment error before the app runs
   • cThe app crashes with a NullPointerException because null safety is bypassed
   • dThe variable behaves as nullable and returns null until assigned
   Show the answer

   Answer: a · A LateInitializationError is thrown at the point of access

   late shifts definite-assignment checks from compile time to runtime, so accessing the field before assignment throws LateInitializationError. Distractor C is tempting because that is exactly the compile-time error you would receive if the field were not marked late.

   Read the full bite: What problem does late solve in Dart?

3. Question 3 of 30

   Given List<int> nums = [1, 2, 3, 4] and bool includeZero = true, which literal produces [0, 2, 4]?

   • a[if (includeZero) 0, for (var n in nums) if (n.isEven) n]
   • b[if (includeZero) 0, nums.where((n) => n.isEven)]
   • c[for (var n in nums) if (n.isEven) n, if (includeZero) 0]
   • d[if (includeZero) [0], for (var n in nums) if (n.isEven) n]
   Show the answer

   Answer: a · [if (includeZero) 0, for (var n in nums) if (n.isEven) n]

   Option A correctly uses collection-if to prepend 0 and collection-for with a nested collection-if to filter evens inside one literal. Option B is tempting because where looks declarative, but without the spread operator it inserts the Iterable object itself as a single element rather than flattening its contents.

   Read the full bite: How do you use collection-if and collection-for to declaratively build a list?

4. Question 4 of 30

   Which statement accurately describes how Dart closures handle captured variables from an enclosing function?

   • aThey copy primitive variables by value and objects by reference at creation time
   • bThey keep the enclosing function's stack frame alive until the closure is destroyed
   • cThey can only be created by anonymous functions, not by named nested functions
   • dThey capture the variable binding by reference in a heap-allocated environment
   Show the answer

   Answer: d · They capture the variable binding by reference in a heap-allocated environment

   Dart closures capture the variable binding by reference in the heap, so the inner function retains access even after the outer function returns and its stack frame is popped. This makes B incorrect because the enclosing function's stack frame does not remain on the call stack after it returns.

   Read the full bite: What is a Dart closure? Write a function that returns a function.

5. Question 5 of 30

   Which statement accurately contrasts Dart's extends, implements, and with keywords for class reuse?

   • aextends inherits from one superclass; implements requires reimplementing every public member; with injects behavior without subtyping.
   • bextends allows multiple superclasses; implements reuses parent code; with establishes an is-a relationship.
   • cextends copies only abstract methods; implements delegates to parent code; with enables multiple inheritance of state.
   • dextends enforces contracts without code reuse; implements inherits method bodies; with requires a shared ancestor.
   Show the answer

   Answer: a · extends inherits from one superclass; implements requires reimplementing every public member; with injects behavior without subtyping.

   Option A is correct because extends provides single inheritance of implementation, implements forces the class to reimplement every public member itself, and with injects reusable behavior without creating an is-a relationship. Option B is wrong because extends does not allow multiple superclasses, implements does not reuse parent code, and with does not establish an is-a inheritance chain.

   Read the full bite: What are the key differences between Dart extends, implements, and with?

6. Question 6 of 30

   Which statement accurately describes a semantic difference between a Dart factory constructor and a generative constructor?

   • aA factory constructor must be named and cannot be declared as the unnamed default constructor.
   • bA factory constructor is invoked like a static method and does not participate in the class constructor namespace.
   • cA factory constructor can return an existing cached instance or a subtype, while a generative constructor always produces a fresh instance of the exact class.
   • dA factory constructor improves memory allocation performance by bypassing implicit object creation.
   Show the answer

   Answer: c · A factory constructor can return an existing cached instance or a subtype, while a generative constructor always produces a fresh instance of the exact class.

   A factory constructor is not required to create a new instance and may return a cached object or subtype, whereas a generative constructor always allocates a fresh instance of the exact class. Option B is tempting because factories resemble static methods, but they remain part of the constructor namespace and are called with standard constructor syntax.

   Read the full bite: What is a Dart factory constructor and common use cases?

7. Question 7 of 30

   You need to parse a dynamic JSON array into List<Product> where some objects may contain missing or mistyped fields. Which approach best preserves type safety and prevents runtime crashes?

   • aUse a factory constructor that checks runtime types and defaults, then map over the list while isolating or skipping invalid rows.
   • bCast each decoded map directly to Product and wrap the entire loop in a single try-catch block.
   • cMake every field in Product nullable and validate the data in the UI layer before displaying it.
   • dUse dart:mirrors to automatically map JSON keys to Product fields at runtime.
   Show the answer

   Answer: a · Use a factory constructor that checks runtime types and defaults, then map over the list while isolating or skipping invalid rows.

   Defensive parsing inside a factory constructor centralizes validation and runtime type checks in the model layer, while isolating or skipping invalid rows during mapping prevents one malformed item from crashing the entire list. Option C spreads uncertainty by pushing null handling into the UI, and C fails because a Map cannot be directly cast to a custom class.

   Read the full bite: How do you model Product and safely parse JSON into List<Product>?

8. Question 8 of 30

   In main(), sync prints 1 and 6 surround a Future(2), microtask(3), Future(4), and microtask(5). What is the output order?

   • a1, 3, 6, 5, 2, 4
   • b1, 6, 3, 2, 5, 4
   • c1, 6, 2, 3, 4, 5
   • d1, 6, 3, 5, 2, 4
   Show the answer

   Answer: d · 1, 6, 3, 5, 2, 4

   The event loop finishes all synchronous code first, then fully drains the microtask queue before processing any event queue callbacks, yielding 1, 6, 3, 5, 2, 4. Option B is tempting because it follows call order, but Dart strictly processes entire microtask batches before touching events.

   Read the full bite: Describe the Dart event loop and queue execution order

9. Question 9 of 30

   What happens when you call listen() again on a single-subscription Dart stream after the first listener has finished?

   • aIt replays all previously emitted events to the new listener
   • bIt returns the original subscription handle and does nothing
   • cIt resumes emitting from where the first listener stopped
   • dIt throws a StateError because only one listener is ever permitted
   Show the answer

   Answer: d · It throws a StateError because only one listener is ever permitted

   A single-subscription stream allows exactly one listener over its entire lifetime, so calling listen again throws a StateError even after the first listener completes. The idea that it resumes where the first left off is a common misconception because the runtime enforces the one-listener contract strictly, treating the stream as consumed rather than pausable.

   Read the full bite: Explain single-subscription vs broadcast Streams in Dart

10. Question 10 of 30

    When using Future.wait to fetch user profiles concurrently, how do you isolate individual failures while preserving successful results?

    • aAwait each fetchProfile call inside a for-loop to handle errors individually and collect the results
    • bAttach catchError to each future before passing the list to Future.wait, then filter out nulls afterward
    • cWrap the Future.wait call in a try-catch block to catch the first error and keep the successful profiles
    • dPass eagerError: true to Future.wait so it returns results for the futures that completed before the failure
    Show the answer

    Answer: b · Attach catchError to each future before passing the list to Future.wait, then filter out nulls afterward

    Attaching catchError to each future guarantees every item resolves, so Future.wait yields a full list where nulls represent failures that can be filtered out. Wrapping Future.wait in try-catch is a common mistake because it catches the batch error but discards all successful profiles that had already completed.

    Read the full bite: Fetch user profiles concurrently and handle individual failures

11. Question 11 of 30

    When a Text widget rebuilds with a new string but the same key, what happens to its Element and RenderObject?

    • aThe new Widget directly updates the RenderObject's properties, since Elements only exist to hold BuildContext references.
    • bThe existing Element compares the new Widget and, if compatible, updates the RenderObject without recreating either object.
    • cBoth the Element and RenderObject are destroyed and recreated to ensure state matches the new Widget configuration.
    • dThe Element is recreated, but the existing RenderObject is retained and updated to avoid expensive recreation.
    Show the answer

    Answer: b · The existing Element compares the new Widget and, if compatible, updates the RenderObject without recreating either object.

    Because the new Widget matches the existing Element's type and key, the Element is updated in place and calls updateRenderObject on the existing RenderObject, avoiding recreation of both. Distractor A is tempting but wrong because the Element is also reused, not recreated, which preserves state and keeps rebuilds inexpensive.

    Read the full bite: Relationship between Widget, Element, and RenderObject trees and their benefits

12. Question 12 of 30

    Why does Scaffold.of(context) return null when called from a build method that returns a Scaffold?

    • aThe build method's context belongs to the widget above the Scaffold, so the Scaffold is not an ancestor.
    • bThe Scaffold has not yet mounted because the build method is still executing.
    • cBuildContext is the widget instance itself, which cannot see widgets returned by its own build method.
    • dScaffold.of searches the entire tree globally, but the AppBar blocks the lookup.
    Show the answer

    Answer: a · The build method's context belongs to the widget above the Scaffold, so the Scaffold is not an ancestor.

    The context in a build method belongs to the widget being built, which sits above the returned Scaffold, so the Scaffold is a descendant and invisible to ancestor lookups like Scaffold.of. Distractor C repeats the common misconception that BuildContext is the widget itself, when it is actually a handle to the Element representing the widget's position in the tree.

    Read the full bite: What is BuildContext? Give two tree-interaction examples.

13. Question 13 of 30

    In Flutter, a parent widget rebuilds frequently due to state changes, but its child displays static data. Which approach correctly prevents the child's build method from running unnecessarily?

    • aOverride shouldRebuild in the child to return false when inputs are unchanged.
    • bWrap the child in a RepaintBoundary to isolate its render layer.
    • cExtract the child into its own StatelessWidget and invoke it with a const constructor.
    • dAssign the child a GlobalKey so the framework preserves its element identity.
    Show the answer

    Answer: c · Extract the child into its own StatelessWidget and invoke it with a const constructor.

    Extracting the child into its own StatelessWidget and invoking it with const creates a build boundary, allowing Flutter to reuse the existing element and skip calling build on that subtree. Wrapping it in a RepaintBoundary is a common misconception because that only reduces paint cost during rasterization, not build-phase work.

    Read the full bite: How can you prevent unnecessary child rebuilds in Flutter?

14. Question 14 of 30

    In Flutter, two sibling widgets need to read and modify the same piece of data. Where should that state live?

    • aInside the child widget that first creates the data, with callbacks to notify the other
    • bIn the closest common ancestor widget, passed down via constructors and callbacks
    • cIn a GlobalKey attached to one sibling so the other can read and mutate it directly
    • dAt the root of the widget tree using an app-wide state management package like Provider
    Show the answer

    Answer: b · In the closest common ancestor widget, passed down via constructors and callbacks

    Placing the state in the closest common ancestor ensures both siblings receive the value and can send events back up via callbacks. Keeping the state inside one child is incorrect because the sibling cannot access it declaratively, violating Flutter's unidirectional data flow.

    Read the full bite: Explain lifting state up with a concrete scenario and benefits

15. Question 15 of 30

    In a Row, a childless Container wrapped in Flexible receives 80 pixels flex share but renders at zero width. Why does an Expanded sibling with 120 pixels fill its share?

    • aFlexible provides unbounded main-axis constraints, so the child collapses to zero, whereas Expanded bounds it to its share.
    • bFlexible applies a loose constraint allowing the child to be smaller than its share, while Expanded applies a tight constraint forcing it to fill.
    • cFlexible does not participate in flex distribution, so the Container sizes to zero width.
    • dExpanded affects main-axis sizing, while Flexible only controls cross-axis stretching.
    Show the answer

    Answer: b · Flexible applies a loose constraint allowing the child to be smaller than its share, while Expanded applies a tight constraint forcing it to fill.

    Flexible passes a loose constraint, letting the child size below its flex share, whereas Expanded passes a tight constraint that forces the child to fill it. Distractor A is wrong because Flexible does participate in proportional space distribution when a flex factor is provided; the Container collapses because loose constraints permit zero width, not because flex is ignored.

    Read the full bite: How do Flexible and Expanded differ in a Row or Column?

16. Question 16 of 30

    Which approach correctly truncates a long Text with ellipsis inside a Row while keeping siblings at their intrinsic sizes?

    • aWrap every child in the Row in Expanded to distribute the available space.
    • bWrap the Text in Expanded, set overflow to TextOverflow.ellipsis, and maxLines to 1.
    • cWrap the Row in a SingleChildScrollView to enable horizontal scrolling.
    • dWrap the Text in a Container with a hardcoded width and set overflow to TextOverflow.ellipsis.
    Show the answer

    Answer: b · Wrap the Text in Expanded, set overflow to TextOverflow.ellipsis, and maxLines to 1.

    Expanded forces the Text to fill only the remaining Row space, giving it a bounded width so ellipsis can truncate properly while siblings keep their natural sizes. A hardcoded Container width avoids the overflow but is brittle across screen sizes and sidesteps Flutter's flex constraint model.

    Read the full bite: Fix RenderFlex overflow in Row with long truncating text

17. Question 17 of 30

    What is the best practice for conditionally rendering ListView or GridView based on screen size in Flutter?

    • aUse OrientationBuilder to show ListView in portrait and GridView in landscape, handling all size variations automatically.
    • bStore the screen width in a state variable updated via setState on rotation, and use an 800-pixel breakpoint to choose between the two views.
    • cWrap the body in a LayoutBuilder, check if constraints.maxWidth is at least 600, and return GridView.builder or ListView.builder with the same itemBuilder.
    • dUse Platform.isAndroid to return GridView on tablets and ListView on phones, since Android tablets run the same OS.
    Show the answer

    Answer: c · Wrap the body in a LayoutBuilder, check if constraints.maxWidth is at least 600, and return GridView.builder or ListView.builder with the same itemBuilder.

    LayoutBuilder uses the parent’s BoxConstraints to choose based on actual available width near the 600 dp breakpoint while sharing the same data source. OrientationBuilder is a tempting distractor because a phone in landscape can be wider than a small tablet in portrait, so width—not orientation—is the correct criterion.

    Read the full bite: Describe a strategy for ListView on phones and GridView on tablets

18. Question 18 of 30

    When implementing a login form with Flutter's Form widget, which statement accurately describes the validation flow?

    • aUse TextEditingControllers for each field, run regex checks in setState inside onChanged, and conditionally display errors via ternary operators in the build method.
    • bAssign a validator to each TextField and call formKey.currentState.validate() inside each field's onChanged to validate on every keystroke.
    • cWrap fields in a Form with a GlobalKey<Form>, then call key.currentState.validate() from the submit button to check all validators.
    • dWrap TextFormField widgets in a Form assigned a GlobalKey<FormState>, then call key.currentState.validate() in the submit handler to aggregate all validator results.
    Show the answer

    Answer: d · Wrap TextFormField widgets in a Form assigned a GlobalKey<FormState>, then call key.currentState.validate() in the submit handler to aggregate all validator results.

    Option D is correct because GlobalKey<FormState> exposes the validate() method that aggregates every descendant TextFormField validator and rebuilds error labels, and it is meant to be called on submission. Option C is tempting because it names the right widgets and method, but GlobalKey<Form> is the wrong generic type and does not provide access to validate().

    Read the full bite: Build and validate a login form with Form and GlobalKey

19. Question 19 of 30

    When programmatically shifting focus between form fields from a parent StatefulWidget, which practice correctly handles FocusNode lifecycle and prevents focus loss?

    • aInitialize the FocusNode as a state field in initState, attach it to a TextField, and call dispose in State.dispose.
    • bCreate the FocusNode inside the build method and pass it to each TextField's focusNode parameter.
    • cInstantiate a new FocusNode inside onEditingComplete every time the user advances to the next field.
    • dRely on Focus widgets to auto-manage nodes and avoid manual FocusNode creation for form traversal.
    Show the answer

    Answer: a · Initialize the FocusNode as a state field in initState, attach it to a TextField, and call dispose in State.dispose.

    Initializing the FocusNode in initState and disposing it in State.dispose keeps the persistent object stable across rebuilds, preventing dropped focus and ChangeNotifier leaks. Creating it in build is a common error because it recreates the node on every rebuild, instantly destroying keyboard focus.

    Read the full bite: What is a FocusNode and why is it useful in forms?

20. Question 20 of 30

    How does Flutter resolve a diagonal drag inside a vertically scrolling list whose items also support horizontal swipes?

    • aBoth recognizers process the gesture simultaneously and the developer must manually reject one inside onPointerDown.
    • bThe framework compares pointer deltas and the recognizer whose primary axis exceeds touch slop first wins the gesture arena.
    • cThe parent scrollable always wins because it receives the pointer first during hit-testing.
    • dHit-testing resolves the conflict by assigning a z-index-like priority so the inner swipe is suppressed by the outer scroll.
    Show the answer

    Answer: b · The framework compares pointer deltas and the recognizer whose primary axis exceeds touch slop first wins the gesture arena.

    Flutter places competing recognizers in a gesture arena and awards victory to the one whose primary axis exceeds touch slop first, causing the losers to reject. The idea that the parent scrollable always wins is a common misconception; hit-testing only invites recognizers into the arena and does not give the scrollable inherent priority.

    Read the full bite: What gesture conflict exists in a scrollable list with horizontal swipes?

21. Question 21 of 30

    In Flutter Navigator 2.0, which component receives a typed route configuration and updates the app state to build the Navigator?

    • aRouter
    • bRouteInformationParser
    • cNavigator
    • dRouterDelegate
    Show the answer

    Answer: d · RouterDelegate

    RouterDelegate receives the typed configuration via setNewRoutePath, updates the app state, and builds the Navigator declaratively. RouteInformationParser only converts raw URL strings into typed configurations and does not manage state or widgets.

    Read the full bite: Explain the core responsibilities of RouterDelegate, RouteInformationParser, and Router in Flutter

22. Question 22 of 30

    Inside a GoRoute builder for path '/users/:userId', what is the correct way to provide the userId to the target widget?

    • aAccess ModalRoute.of(context).settings.arguments as the userId
    • bParse context.location manually to pull out the userId substring
    • cPass the full user object through state.extra and cast it in the builder
    • dRead state.params['userId'] and handle the possibility of a null value
    Show the answer

    Answer: d · Read state.params['userId'] and handle the possibility of a null value

    GoRouter exposes matched path parameters in the state.params map, and because the map values are nullable Strings you must null-check before using the userId. Using ModalRoute.of or parsing context.location manually bypasses GoRouter's declarative state, while state.extra breaks deep linking and web navigation because it is not serialized to the URL.

    Read the full bite: Implement a GoRouter path parameter route and access userId in a widget

23. Question 23 of 30

    Why does StatefulShellRoute.indexedStack preserve a tab's pushed pages and scroll position when the user switches away and returns?

    • aIt serializes each branch to disk on every tab change
    • bAll branches share one Navigator that snapshots its stack
    • cIt disposes and recreates each branch from a saved route string
    • dEach branch keeps its own Navigator and stays mounted in the IndexedStack
    Show the answer

    Answer: d · Each branch keeps its own Navigator and stays mounted in the IndexedStack

    Each StatefulShellBranch owns a Navigator and remains mounted in the IndexedStack, so its state survives switches. A single shared Navigator (last option) would mix the tabs' histories together.

    Read the full bite: Per-tab navigation stacks with StatefulShellRoute

24. Question 24 of 30

    A details screen should rebuild only when totalPrice exceeds $100, not when other CartModel fields change. Which implementation is correct?

    • aUse Selector with a selector returning totalPrice > 100 so it rebuilds only when the boolean flips
    • bUse context.watch on the entire CartModel and check totalPrice > 100 inside build
    • cUse context.read inside build to get totalPrice and compare it to 100
    • dUse context.select in initState to cache the boolean and reference it during build
    Show the answer

    Answer: a · Use Selector with a selector returning totalPrice > 100 so it rebuilds only when the boolean flips

    Selector listens to a derived slice and uses equality checks to rebuild only when the selected boolean changes. Watching the entire CartModel would cause unnecessary rebuilds whenever unrelated fields mutate.

    Read the full bite: Difference between context.watch, context.read, and Selector in Provider and Riverpod

25. Question 25 of 30

    Which strategy best scopes widget rebuilds to a single row when toggling a favorite in a long Flutter list?

    • aUse a global state solution like Bloc that emits a new immutable copy of the entire product list whenever any favorite toggles.
    • bWrap the ListView in a StatefulWidget and call setState in the parent each time a favorite button is pressed.
    • cAdd a mutable isFavorite field to the product model and pass that model to each list item, expecting the framework to detect the internal change.
    • dAssign a ValueKey with the productId to each row, pass a per-item ValueNotifier to a const widget, and wrap only the favorite icon in a ListenableBuilder.
    Show the answer

    Answer: d · Assign a ValueKey with the productId to each row, pass a per-item ValueNotifier to a const widget, and wrap only the favorite icon in a ListenableBuilder.

    Option D isolates per-item state by pairing a ValueNotifier with ListenableBuilder inside a const widget with stable keys, so only the icon rebuilds. Option A is tempting because immutable state is usually good practice, but emitting an entire new list causes every row to rebuild instead of just the tapped item.

    Read the full bite: How do you manage product list and favorite state without full rebuilds?

26. Question 26 of 30

    What is the key mechanical difference between manually lifting state up and using Provider to share it?

    • aProvider prevents all widget rebuilds by removing the need for setState
    • bProvider stores state as a global singleton accessible from any widget
    • cProvider uses InheritedWidget to let descendants access state without intermediate widgets passing it
    • dManual callback passing is cleaner and more maintainable in deeply nested widget trees
    Show the answer

    Answer: c · Provider uses InheritedWidget to let descendants access state without intermediate widgets passing it

    Provider exposes state through an InheritedWidget, allowing descendants to access or mutate data directly without intermediate widgets accepting and forwarding arguments. The distractors repeat common misconceptions: Provider is scoped rather than global, manual callbacks become unwieldy in deep trees, and Provider localizes rebuilds rather than eliminating them entirely.

    Read the full bite: Explain lifting state up in Flutter and how Provider simplifies it

27. Question 27 of 30

    Which strategy best distinguishes a transport timeout from a malformed JSON payload when using Dio?

    • aTreat any non-2xx HTTP status as a connectivity error and retry with exponential backoff
    • bCatch all exceptions generically and display a single toast message
    • cCheck DioExceptionType for connectivity issues, then parse JSON in a separate try-catch after confirming HTTP success
    • dInspect the exception message string for timeout or format keywords
    Show the answer

    Answer: c · Check DioExceptionType for connectivity issues, then parse JSON in a separate try-catch after confirming HTTP success

    The correct answer reflects the layered approach: inspect DioExceptionType for transport failures first, then isolate JSON deserialization in its own try-catch so schema mismatches are not confused with wire errors. Option B is wrong because a generic catch block makes it impossible to tell whether the failure came from the network or the mapper.

    Read the full bite: Describe a robust error handling strategy for network requests

28. Question 28 of 30

    When evaluating manual JSON serialization against json_serializable for a growing Dart codebase, which trade-off is most accurate?

    • ajson_serializable slows down app startup because generated serialization code adds runtime overhead.
    • bjson_serializable eliminates the need for handwritten converters even when handling non-standard JSON shapes.
    • cManual serialization is always simpler for small teams since it avoids the overhead of build_runner and generated files.
    • dManual serialization avoids build dependencies but risks boilerplate drift, whereas code generation adds compile-time latency while producing equivalent runtime performance.
    Show the answer

    Answer: d · Manual serialization avoids build dependencies but risks boilerplate drift, whereas code generation adds compile-time latency while producing equivalent runtime performance.

    Option D captures the core trade-off: manual methods avoid build steps but become error-prone at scale, while json_serializable introduces build_runner latency but generates plain Dart that performs identically at runtime. Option A is a tempting distractor because many candidates mistakenly believe code generation affects end-user performance, but the card emphasizes runtime is identical.

    Read the full bite: Compare manual JSON serialization versus json_serializable

29. Question 29 of 30

    Why might you move network request logic out of a widget that currently uses setState and into a state management library?

    • aBecause the logic becomes hard to unit test, easy to duplicate, and can leak if the widget disposes mid-request
    • bBecause state management libraries automatically cache HTTP responses for offline use without extra configuration
    • cBecause setState does not support asynchronous operations like Futures in initState
    • dBecause calling setState inside initState is forbidden by the Flutter framework and throws a runtime error
    Show the answer

    Answer: a · Because the logic becomes hard to unit test, easy to duplicate, and can leak if the widget disposes mid-request

    The card identifies these exact setState limitations: logic trapped in the widget is hard to test, easy to duplicate across screens, and can leak if setState is called after disposal. Distractor B is wrong because setState can be used after a fetch initiated in initState; the issue is maintainability, not a framework ban.

    Read the full bite: How would you manage network request state in a Flutter widget?

30. Question 30 of 30

    What is the fundamental reason legacy SharedPreferences operations like getInstance and setters are asynchronous?

    • aThe legacy API has no in-memory cache, so every read and write must asynchronously fetch from native storage.
    • bGetter methods such as getInt return Futures, requiring the entire API to be async for consistency.
    • cLocal storage operations are handled by a background isolate, so Futures are needed to marshal results back to the UI isolate.
    • dDart runs on a single event-loop isolate for UI work, and platform channel disk I/O must not block that thread.
    Show the answer

    Answer: d · Dart runs on a single event-loop isolate for UI work, and platform channel disk I/O must not block that thread.

    Dart's single event-loop isolate drives the UI, so blocking platform channel disk I/O would drop frames and create jank. Distractor B is wrong because legacy getters like getInt are synchronous once the in-memory cache is populated by getInstance, which the card identifies as a common misconception.

    Read the full bite: Why is Flutter local storage async and how do you use shared_preferences?