Top 50 Flutter Interview Questions & Answers for 2026: From Junior to Lead

Preparing for a Flutter interview in 2026 requires a deep understanding of the framework's internals and best practices for high-performance applications. This guide provides concise, accurate answers categorized by professional level.

Level 1: Junior & Associate Fundamentals

1. What is Flutter and how does its rendering differ from React Native?

Flutter is a UI toolkit that uses its own rendering engine (Impeller/Skia) to draw every pixel manually. Unlike React Native, which uses a bridge to communicate with native platform widgets, Flutter skips the bridge for UI, leading to more consistent performance across devices.

2. Difference between StatelessWidget and StatefulWidget?

• StatelessWidget: Immutable. Its properties cannot change once it is built.
• StatefulWidget: This widget maintains a State object that persists while the widget tree is rebuild. Use setState() to trigger a rebuild when data changes.

3. Explain the difference between main() and runApp().

main() is the entry point of the Dart program. runApp(Widget app) is the function that takes the root widget and attaches it to the screen, starting the Flutter framework.

4. Explain final vs const in Dart.

• final: A single-assignment variable. Its value is determined at runtime.
• const: A compile-time constant. Its value must be known during compilation. Const objects are canonicalized for better memory efficiency.

5. What is pubspec.yaml?

The metadata and configuration file for a Flutter project. It manages dependencies, assets (images, fonts), project versioning, and environment constraints.

6. What is BuildContext?

It is a handle to the location of a widget in the widget tree. It is used to look up services like Theme.of(context), MediaQuery.of(context), or to find the nearest InheritedWidget.

7. Hot Reload vs Hot Restart?

• Hot Reload: Injects code changes into the Dart VM while keeping the app state. It works by rebuilding the widget tree.
• Hot Restart: Rebuilds the app from scratch, losing all states. It is required when changing main(), global variables, or static fields.

8. What is the purpose of the Scaffold widget?

It provides the high-level API for the Material Design layout structure, including the appBar, body, floatingActionButton, drawer, and bottomNavigationBar.

9. How do you handle asynchronous operations in Dart?

Using the Future API along with async and await keywords. For continuous data streams, Dart provides the Stream class.

10. What is Sound Null Safety?

A Dart feature ensures that variables cannot contain null unless you explicitly allow it using the ? operator. This eliminates a whole class of runtime "null pointer" errors during development.

Level 2: Mid-Level & Intermediate

11. Describe the StatefulWidget Lifecycle.

1. createState(): Called when the framework is told to build the widget.
2. initState(): For one-time initialization (e.g., listeners).
3. didChangeDependencies(): Called when a dependency (like InheritedWidget) changes.
4. build(): Required method to build the UI.
5. didUpdateWidget(): Called when the parent widget changes its configuration.
6. deactivate() / dispose(): For cleanup and removing the state.

12. What are Keys and when are they necessary?

Keys uniquely identify widgets. They are necessary when modifying a collection of stateful widgets (like a list) where items change order or are removed, ensuring the framework preserves the correct state for the correct widget.

13. Explain the three trees in Flutter.

1. Widget Tree: The declarative configuration (the blueprint).
2. Element Tree: Manages the lifecycle and links widgets to their rendered counterparts. It is the "glue."
3. RenderObject Tree: The low-level tree that handles sizing, layout, and painting.

14. What is an InheritedWidget?

The base class for widgets that efficiently propagate information down the tree. It allows children to subscribe to data changes without passing data through every constructor (prop drilling).

15. What are Streams and how do you use them?

A Stream is a source of asynchronous data events. You consume them using a StreamBuilder or by listening directly. They are ideal for real-time updates like web sockets or database changes.

16. Provider vs BLoC: When to use which?

• Provider: Best for simple to medium state management. It is easy to learn and follows standard Flutter patterns.
• BLoC: Best for complex business logic. It strictly separates logic from UI using Streams, making it highly testable and predictable for large enterprise apps.

17. How do Dart Isolates work?

Isolates are Dart's way of achieving parallelism. Since Dart is single-threaded, it uses Isolates (separate memory heaps and threads) to perform heavy calculations without blocking the main UI thread (event loop).

18. What are Extension Methods?

They allow you to add new functionality to existing classes (even those you don't own) without using inheritance or modifying the original class.

19. MainAxisAlignment vs CrossAxisAlignment?

• MainAxis: The axis the Flex widget (Row/Column) grows in (Horizontal for Row, Vertical for Column).
• CrossAxis: The axis perpendicular to the main axis.

20. When do you use a GlobalKey?

Use a GlobalKey when you need to access the state of a widget from a different part of the tree or when you need a widget to persist across the screen even if its parent changes location.

Level 3: Senior & Advanced

21. How to optimize Flutter app performance?

• Use const constructors everywhere possible.
• Minimize the use of Opacity (use Visibility or AnimatedOpacity).
• Use ListView.builder for long lists to enable lazy loading.
• Use RepaintBoundary for complex UI clusters that don't change often.
• Avoid heavy computation in the build() method.

22. Explain the Domain, Data, and Presentation layers in Clean Architecture.

• Domain: Pure Dart logic (Entities, Repository Interfaces, Use Cases). No outside dependencies.
• Data: Implementation of repositories, API calls (Models), and local databases.
• Presentation: UI widgets and state management (BLoC/Riverpod) that interact with Use Cases.

23. How do Method Channels work?

They enable communication between Dart and native platform code (Kotlin/Swift). You send a message via a MethodChannel, and the native side listens via a MethodCallHandler, returning a result asynchronously.

24. Navigator 1.0 vs Navigator 2.0 (Router API)?

• 1.0: Imperative (push/pop). Simple but hard to maintain for complex deep linking.
• 2.0: Declarative. It uses a Router to map the app state directly to the navigation stack, which is essential for web and complex deep linking.

25. What is Tree Shaking?

A build optimization where the compiler removes unused code and assets (like unused icon glyphs) during the release build, significantly reducing the binary size.

26. FutureBuilder vs StreamBuilder?

• FutureBuilder: Used for a one-time asynchronous task (e.g., an API call).
• StreamBuilder: Used for continuous data updates (e.g., a countdown timer or a chat list).

27. What is Dependency Injection (DI) and how is it implemented?

DI is a pattern where an object's dependencies are provided by an external source rather than created within the object. In Flutter, it is commonly implemented using GetIt or Provider/Riverpod.

28. How does Flutter achieve 60/120 FPS?

By utilizing a high-performance graphics engine (Impeller/Skia) and a reactive framework that minimizes re-layouts. It synchronizes the build and paint phases with the screen's refresh rate (vsync).

29. What is the CustomPainter?

A class that provides a Canvas object. It allows you to draw low-level graphic primitives like lines, circles, and paths manually for custom UI elements that standard widgets cannot achieve.

30. How to handle deep linking in Flutter?

By using a declarative routing system (like go_router) that parses incoming URLs and maps them to the appropriate state and screen in the application.

Level 4: Expert & Specialty

31. What is the difference between Service and Repository?

• Repository: An abstraction over data sources. Its job is to fetch data and map it to domain entities.
• Service: Handles technical implementations like Firebase Messaging, Local Auth, or specialized business calculations that don't fit the "data fetching" role of a repository.

32. Can Mixins have constructors?

No. Mixins in Dart cannot define constructors. They are designed for horizontal code reuse across hierarchies and are applied to classes using the with keyword.

33. What is a "Tear-off" and why use it?

A tear-off is passing a method name as a callback without a closure (e.g., onPressed: myAction instead of onPressed: () => myAction()). It reduces code verbosity and slightly improves performance by avoiding extra anonymous function wrappers.

34. How do you implement Integration Testing?

Using the integration_test package. Unlike unit or widget tests, integration tests run on a real device/emulator to verify the end-to-end flow of the app, simulating real user input and network conditions.

35. What is SchedulerBinding?

It is the bridge between the Flutter framework and the engine’s scheduler. It is used to schedule tasks to run at specific times relative to the frame lifecycle, such as using addPostFrameCallback to execute logic after rendering completes.

36. Microtask Queue vs Event Queue?

• Microtask Queue: Very high priority. Tasks here run immediately after the current synchronous block and before the event loop continues.
• Event Queue: Standard priority. Handles external events like I/O, timers, and pointer events.

37. What is the Hero widget and how does it work?

The Hero widget performs "shared element transitions." When navigating between routes, the framework finds two Hero widgets with matching tags and animates the transition from the source position to the destination.

38. How to handle Localization (i18n) efficiently?

By using the flutter_localizations package and setting up .arb files. This allows for type-safe access to strings via AppLocalizations, ensuring the app can scale across multiple languages.

39. What are Slivers?

Slivers are low-level scrollable portions. They are used within a CustomScrollView to create complex scrolling effects, such as headers that collapse or expand as the user scrolls.

40. Why should you avoid IntrinsicHeight?

IntrinsicHeight is computationally expensive because it requires an extra layout pass (an "o(n^2)" operation in some cases). It should be avoided inside lists or deep trees to prevent frame drops.

41. How to reduce app size (Binary Size)?

• Use the --split-debug-info and --obfuscate flags.
• Compress large assets.
• Use flutter build apk --split-per-abi to create architecture-specific APKs.
• Remove unused packages.

42. What is FittedBox?

A layout widget that scales its child to fit within the available space based on a BoxFit rule. It is essential for responsive designs where text or images must scale without overflowing.

43. When to use CustomScrollView over ListView?

Use CustomScrollView when you need advanced scroll effects like sticky headers, a mix of lists and grids, or widgets that react to the scroll position (Slivers).

44. What is the Listenable interface?

An interface for objects that can notify listeners when their internal state changes. ChangeNotifier is the most common implementation used to trigger UI rebuilds in state management.

45. Provider vs Consumer in state management?

• Provider.of(context): Rebuilds the entire widget that calls it.
• Consumer: A more granular widget that only rebuilds its own builder child, offering better performance for large widgets.

46. How do you handle Background Tasks?

For heavy CPU work, use Isolates. For tasks that must run while the app is closed (like periodic sync), use platform-specific packages like workmanager.

47. Purpose of AutomaticKeepAliveClientMixin?

It allows a widget (usually in a PageView or ListView) to persist its state even when it is scrolled out of view, preventing the framework from disposing of it.

48. How to manage Environment Variables?

Use Flavors or --dart-define to pass variables at build time. This allows for separate configurations for Dev, Staging, and Production environments without modifying code.

49. What is the Semantics widget?

It provides descriptions and traits to the platform's accessibility engine (like talkback/voiceover). It is critical for making your app usable for visually impaired users.

50. How do you migrate a Flutter project safely?

1. Update your Flutter SDK version.
2. Update dependencies in pubspec.yaml using flutter pub outdated.
3. Use dart fix to handle automated breaking change migrations.
4. Perform regression testing on the entire rendering flow.

Summary

To succeed in a Flutter interview in 2026, you must demonstrate a grasp of Performance Optimization, Clean Architecture, and Reliable State Management. Understanding why the framework behaves a certain way is the key distinguishing factor of an expert developer.

Good luck with your journey!