Top Flutter Interview Questions and Answers

Anand Gaur

Mobile Tech Lead @ TCS | Android, Kotlin, KMP, Jetpack Compose | AI in Mobile Development | Ex-Samsung & Tech Mahindra | 1M+ Impressions | 26K+ Connections | Technical Blogger (Medium) | Mentor for mobile developers

Published Jun 20, 2025

Flutter is one of the most in-demand frameworks for cross-platform app development. Whether you’re a fresher or an experienced developer preparing for a job interview, these Flutter interview questions with detailed answers will help you understand core concepts and prepare confidently.

1. What is Flutter?

Flutter is an open-source UI software development framework created by Google. It allows developers to build natively compiled applications for mobile (Android/iOS), web, and desktop from a single codebase using the Dart programming language.

Key Features of Flutter:

Hot Reload: Makes it easy to experiment, build UIs, and fix bugs.
Single Codebase: Write once and run on multiple platforms.
Rich Set of Widgets: Helps in creating beautiful UIs.
High Performance: Compiles to native ARM code.

Example:

2. Explain Stateful vs Stateless widgets.

In Flutter, widgets are the building blocks of UI. They are divided into:

StatelessWidget:

A widget that does not change during runtime.
Used when your UI doesn’t depend on any dynamic data.

StatefulWidget:

A widget that can change its state during runtime.
Useful when you need to update the UI based on user interaction or async data.

3. What is the difference between hot reload and hot restart?

Example Use Case:

Use hot reload when you make UI changes or small logic updates.
Use hot restart when you make changes in or need a clean state.

4. What is BuildContext in Flutter?

is a handle to the location of a widget in the widget tree.

It is used to:

Access theme, media query, and navigator
Find the nearest widget of a specific type (using )

Example:

5. What is the difference between Navigator.push and pushReplacement?

: Pushes a new route on top of the stack.
: Replaces the current route with the new one.

Example:

Use when you don’t want the user to return to the previous screen.

6. What is Future and FutureBuilder?

Future:

Represents a value that will be available in the future (after some async operation completes).

FutureBuilder:

A widget that waits for the Future and builds UI based on its state (loading, completed, error).

7. How does setState() work?

is used to notify the Flutter framework that the internal state of a widget has changed, and the widget needs to be rebuilt.

Example:

When is called:

Flutter marks the widget as dirty.
Schedules a build for the widget.
Only that widget (and its children) is rebuilt.

8. What are Keys in Flutter?

Keys help Flutter identify which widget changed when the widget tree is rebuilt.

Use Cases:

Preserving widget state in lists
Optimizing performance during updates
For animations and reordering items

9. What is the use of Provider in Flutter?

is a state management solution in Flutter that allows you to share and manage state across your app.

Why Provider?

Simple to understand and implement
Works well with ChangeNotifier
Scalable for small to medium projects

Example:

Use it in the widget tree:

Access it in widgets:

10. What is the difference between mainAxisAlignment and crossAxisAlignment?

These properties define how children are aligned in Row and Column widgets.

: Aligns children along the main axis (horizontal in Row, vertical in Column).
: Aligns children along the cross axis (vertical in Row, horizontal in Column).

11. What are Mixins in Dart? How are they used in Flutter?

A Mixin is a way of reusing code in multiple classes without inheritance.

Key Points:

Used with the keyword
Helps in adding functionality to multiple classes
Common in Flutter for reusable logic like

12. What is the difference between BLoC and Provider?

BLoC (Business Logic Component):

Based on Streams and Sinks
More structured and testable
Good for large, complex apps

Provider:

Simpler, based on ChangeNotifier
Ideal for small to medium apps

13. What is the role of WidgetsBinding in Flutter?

connects the Flutter framework to the platform.

Key Uses:

Scheduling frames
Listening to lifecycle events
Accessing for UI updates after build

14. How do you make API calls in Flutter?

Use the or package.

Using http:

15. How to handle offline mode in Flutter?

Use:

to detect network
or for local caching
Fallback to local data when offline

Example:

16. What is Flutter’s rendering pipeline?

Flutter rendering pipeline goes through several phases:

Build Phase → Widgets are created
Layout Phase → Size and position calculated
Paint Phase → Pixels are drawn to screen
Compositing → Layers are merged
Rasterizing → Sent to GPU
Displaying → Shown on screen

Understanding this helps optimize performance and animations.

17. What are some performance optimization tips in Flutter?

Use constructors where possible
Use instead of
Avoid rebuilding widgets unnecessarily
Use for expensive widgets
Use for images and lists
Minimize widget tree depth

18. What are Isolates in Dart? How are they used in Flutter?

Isolates are Dart’s way of doing multi-threading without shared memory.

Each isolate has its own memory and event loop
Communication is done via message passing
Helps in doing heavy computation off the main UI thread

Example:

is a helper function that spawns a new isolate.

19. How do you implement a responsive UI in Flutter?

You should use:

and
package (optional)

Example:

This helps your app run on:

Small phones
Tablets
Web

20. How do you structure a large-scale Flutter project?

Use Clean Architecture or Feature-Based Structure.

Suggested Folder Structure:

Benefits:

Scalable
Testable
Maintains separation of concerns

21. How does Flutter handle memory management?

Flutter uses Dart’s garbage collector, which:

Reclaims memory of unreferenced objects
Automatically manages memory lifecycle
Avoids memory leaks (if references are properly handled)

Best Practices:

Use in to clean up , , etc.
Avoid large widget trees that rebuild unnecessarily

22. What is a GlobalKey and when should you use it?

A gives access to the state of a widget across the app, even if it rebuilds.

Use Cases:

Form validation
Access widget state outside of its own widget tree

Use it sparingly. Overuse can lead to performance and architectural issues.

23. How can you handle background tasks in Flutter?

Use:

(for Android/iOS background tasks)
(for Android periodic tasks)
(for heavy CPU tasks)

For push notifications and silent background updates, integrate with:

Firebase Cloud Messaging (FCM)
Background fetch plugins

24. How do you secure sensitive data in Flutter?

Use the following packages:

– stores data in Keychain/Keystore
– for encrypting text before saving
Obfuscate API keys with or native secrets

Example:

25. What is BuildContext in Flutter? And why is it needed?

is like an address or reference to a location in the widget tree. It tells Flutter where the widget is located in the widget hierarchy. Every widget in Flutter has a , and this context is very important when we want to:

Access theme data
Show dialogs or snackbars
Navigate to other screens
Access inherited widgets

Imagine the widget tree is like a large family tree. If you want to find out something about your grandparents (parent widgets), you need to know where you are in the tree. helps Flutter know that.

Example:

In this example, we’re using the context to access the current theme.

So, without , widgets won’t know their place in the UI structure and can’t interact with the rest of the widget tree properly.

26. What is Hot Reload and Hot Restart in Flutter?

Hot Reload:

Hot Reload helps you quickly see the changes in your code without restarting the app.
When you save your file, Flutter injects the updated code into the Dart VM.
It preserves the current state of the app.
Fast and useful for UI changes.

Example: If you’re changing colors, text, or layout, Hot Reload will reflect changes immediately without losing your current screen.

Hot Restart:

Hot Restart kills the running app and starts it again.
It resets the app state to the initial state (just like restarting an app manually).
Takes slightly longer than Hot Reload.

Use Hot Restart when:

You’ve made major changes to the app.
You want to test from scratch.

27. Differentiate between named parameters and positional parameters in Flutter.

Named Parameters:

You can specify which parameter you’re passing using the name.
More readable, especially with many parameters.
You can set default values and make them optional or required.

Example:

Call it like:

Positional Parameters:

Order matters. You must pass them in the correct order.
They are defined using parentheses.

Example:

Call it like:

Use named parameters when:

You have many parameters
You want better code readability

Use positional parameters when:

You have a few parameters that must be passed in a specific order

28. What is the difference between main() and runApp() functions in Flutter?

is the entry point of every Dart application, including Flutter apps.
It’s where your app starts executing.

is a Flutter-specific function that takes a widget and makes it the root of the widget tree.
It tells Flutter to start rendering from that widget.

So,

= Dart entry point
= Flutter entry point that attaches the widget tree to the screen

29. What is pubspec.yaml file and what does it do?

The file is like the brain of your Flutter project’s configuration. It tells Flutter everything about your project including:

Project metadata like name, description, version
Dependencies (packages you want to use like , , etc.)
Assets (images, fonts, etc.)
Dev dependencies (tools for testing, formatting, etc.)
Flutter settings (like fonts, assets used by the app)

Example content:

Whenever you add or update packages in this file, you run to install them. Without , your Flutter app wouldn’t know what packages or files it needs to work.

30. What are different build modes in Flutter?

Flutter has three main build modes:

Debug Mode

Used during development.
Includes debugging tools.
Slower performance due to additional checks.
Hot Reload is available.

2. Profile Mode

Used to profile app performance.
Some debugging tools are disabled.
No Hot Reload.
Used for performance analysis.

3. Release Mode

Used when publishing the app.
Optimized for speed and performance.
No debug information.
App size is smaller.

To build for these modes:

Use Debug for development, Profile for checking performance, and Release for publishing.

31. What is Fat Arrow Notation in Dart?

Fat arrow () is a shorthand for returning a single expression in Dart. It’s commonly used in simple functions or one-liner widgets.

Instead of writing:

You can write:

It’s shorter and more readable when you don’t need multiple lines.

Also used in widget building:

Use it only for simple expressions, not complex logic.

32. What is the difference between Expanded and Flexible widget?

Both and are used inside , , or widgets to control how a child widget should occupy space.

Expanded

Takes all available space in the main axis.
Forces the child to fill that space.

Example:

Flexible

Also takes available space, but allows the child to decide how much space it wants.
More flexible (as the name suggests).

Example:

If you want a child to take all remaining space → use If you want to give the child flexibility → use

33. What are Slivers?

Slivers are a set of widgets in Flutter designed to give you fine-grained control over scrolling effects. The term “sliver” means a portion of the scrollable area. When you’re building a scrollable layout, especially with , slivers allow you to build complex and flexible scrolling effects like collapsing toolbars, sticky headers, etc.

Flutter provides various sliver widgets:

: An app bar that can expand, collapse, or remain pinned while scrolling.
: A sliver that displays a linear list of children.
: A sliver that displays children in a grid.

Example:

Use slivers when you need advanced control over scroll behavior and UI performance in large or dynamic lists.

34. What is the extension method in Dart?

Extension methods allow you to add new functionalities to existing classes without modifying them. This is useful when you want to extend a class (like , , or any custom class) with helper methods.

Example:

With extension methods, you don’t need to create utility classes or modify existing class definitions. They’re perfect for cleaner and readable code, especially when dealing with repeated logic.

35. Explain the mounted property. How is it important and when to use it?

In Flutter, the property is a boolean that tells you whether the object is currently in the widget tree.

Every in Flutter has a object, and becomes when the is inserted into the widget tree (i.e., it’s active and visible). It becomes when the object is removed or disposed.

You should use :

To check if it’s still safe to call
To avoid calling UI updates on widgets that are no longer visible

Why is it important?

Let’s say you are making an API call inside a widget. The API might return data after a few seconds. But during this time, if the user navigates to a different screen, your widget may no longer be visible. If you then call on that widget, it will throw an error because the widget was removed.

Example:

Here, we check before calling to make sure the widget is still part of the widget tree.

In short:

prevents memory leaks and exceptions.
It ensures safe UI updates in async tasks or future callbacks.

36. What is the difference between Container and SizedBox widget?

Both and are layout widgets in Flutter, but they serve slightly different purposes and are used in different scenarios.

Container:

is a versatile widget that can have multiple properties like padding, margin, alignment, decoration, color, width, height, etc.
It’s used when you want to customize the layout, decoration, and constraints of a widget.

Example:

Here, Container adds size, color, and child alignment.

SizedBox:

is a simple widget used to give fixed width or height to its child, or to create empty space between widgets.
It’s lighter than because it doesn’t support decoration, padding, or alignment.

Example:

This is often used as spacing between two widgets.

Another example:

This will wrap the button with a fixed size.

37. What do you mean by Null-aware operators?

Null-aware operators in Dart are special operators used to handle values that might be . They help you write safer and more concise code by avoiding null pointer exceptions. These operators are very useful in Flutter because many variables (like user data, inputs, or async responses) can be null.

Here are the most common null-aware operators:

(If-null operator):

Returns the value on the left if it’s not null, otherwise returns the value on the right.

2. (Null-aware assignment):

Assigns a value only if the variable is null.

3. (Null-aware access operator):

Calls a method or accesses a property only if the object is not null.

4. (Null assertion operator):

Tells Dart that a value is definitely not null (use with caution).

If is null, it will throw a runtime error.

Why are they useful?

In real-world Flutter apps, data often comes from APIs, forms, or databases where values can be null. Using these operators makes the code:

Cleaner
More readable
Safe from null errors

38. What is AppLifecycleState?

is an enum provided by Flutter that helps you track the lifecycle state of your app — whether it's active, inactive, paused, or detached. It is especially useful when you want to perform actions based on the app's visibility and interaction with the user.

Here are the different states of :

AppLifecycleState.resumed: The app is visible and responsive to user input. (Foreground)
AppLifecycleState.inactive: The app is in an inactive state and not receiving user input. It can happen when there’s a call or the app is transitioning.
AppLifecycleState.paused: The app is not currently visible to the user, not receiving input, but still running in the background.
AppLifecycleState.detached: The app is still hosted on a flutter engine but is detached from any view. This state is rarely used in day-to-day app development.

How to use it?

You typically use it inside a by mixing in the .

Example:

Why is it useful?

You can pause timers or animations when the app is not visible.
Save unsaved data or state when the app goes into the background.
Resume tasks or re-authenticate when the app is resumed.

This is especially important for apps that handle sensitive information, streaming, or real-time updates.

39. What is the difference between NetworkImage and Image.network in flutter?

Both and are used to load images from the internet in Flutter, but they are used in slightly different ways.

1. Image.network:

is a widget.
It directly creates an image widget that displays an image from a URL.
It is very convenient and easy to use.
Internally, it uses under the hood.

Example:

This widget loads the image and displays it in the UI.

2. NetworkImage:

is not a widget. It is an .
You use it when you want more control over how the image is loaded and used.
Commonly used with widgets like , , or .

Example with widget:

Example with :

In Short:

Use when you want a quick and simple way to show images.
Use when you need to use the image as a provider (like for background images or with caching and decoration).

40. Explain async, await and Future.

In Dart (and Flutter), asynchronous programming is handled using , , and . These are used when you perform operations that take some time to complete, like fetching data from the internet, reading a file, or accessing a database.

What is a Future?

A represents a value that might not be available yet. It’s like a promise that something will be available later.

Example:

Here, returns a Future that completes after 2 seconds with the string "Data loaded".

You can use to handle the result:

What is async?

is a keyword you add to a function to tell Dart that the function will perform asynchronous operations and return a .

Example:

What is await?

is used to wait for a to complete before moving to the next line.

It pauses the function execution until the awaited future completes.
Can only be used inside functions marked as .

Why is it useful?

Instead of writing nested callbacks ( chains), and let you write asynchronous code in a way that looks and behaves like synchronous code. It makes your code easier to read and maintain.

Real-world Flutter example:

In Flutter apps, you’ll often use , , and when:

Making API calls
Reading local files
Waiting for animations
Delaying UI effects

These tools are essential for writing responsive apps that don’t block the UI thread.

41. What is resizeToAvoidBottomInset? When should we use it?

is a property of the widget in Flutter. It controls whether the body of the scaffold should resize when the on-screen keyboard appears.

Why do we need it?

When you’re building a form with input fields (like ) and the user taps on one, the keyboard pops up. If your layout doesn't adjust, the keyboard might overlap and hide the input fields. That’s where helps.

Default behavior:

By default, , which means the layout automatically resizes and makes space for the keyboard.

Example:

In this case, when the keyboard appears, the layout moves up to prevent the from being hidden.

When to set it to false?

If you don’t want the layout to resize (e.g., you are handling it manually or using some other technique), you can set it to :

This keeps the layout fixed, and the keyboard may overlap the UI.

When should we use it?

Use when you have forms or input fields and want Flutter to handle layout resizing automatically.
Use only if you want full control over the UI during keyboard appearance, such as with custom scroll logic or animations.

In short, is useful to prevent input fields from getting hidden behind the keyboard.

42. What is Flutter Tree Shaking?

Flutter Tree Shaking is a compiler optimization technique that removes unused code from your app during the release build process. It ensures that only the parts of the code that are actually used in your app are included in the final compiled output.

This helps in:

Reducing the app size
Improving the performance
Making the app more efficient

Why is it called “Tree Shaking”?

Imagine your code as a big tree with branches (classes, methods, variables). Some of these branches are never used in your app. Tree shaking shakes this tree and removes all the unused branches (dead code), keeping only what is necessary.

When does it happen?

Tree shaking happens only in release mode. That means when you build your app using:

Flutter compiles Dart code to native machine code using Dart’s AOT (Ahead-of-Time) compiler. During this compilation, tree shaking is applied.

Example:

If you have imported a package but never used it:

If you never use any chart from this package, tree shaking will remove this code during release build.

How is it helpful?

Smaller APK/IPA size
Faster app startup
Less memory consumption

43. What is InheritedWidget in Flutter?

is a special kind of widget in Flutter that allows data to be efficiently passed down the widget tree and accessed by its descendants. It’s often used when you want to share data across many widgets without having to manually pass it through every widget constructor.

Why is it important?

Normally in Flutter, if you want to pass some data from a parent widget to deeply nested child widgets, you have to pass that data through each level manually. This becomes very messy and difficult to manage in large applications. solves this by allowing any widget down the tree to access the data directly from the context.

44. What is InheritedWidget in Flutter?

Why is it important?

Real-life example:

Let’s say you have a , , or object that multiple widgets need to access. Instead of passing it to each widget manually, you wrap your widget tree in an and then access it anywhere using .

How to create a custom InheritedWidget:

Usage:

Important method:

: This tells Flutter whether widgets that depend on this data should rebuild when the data changes.

Built-in examples of InheritedWidgets:

These are all using internally.

45. Differentiate between Stream and Future in Flutter.

Both and are used for asynchronous programming in Dart/Flutter, but they are designed for different use cases.

Future

A is used when you expect a single result after some time.

It represents a computation or task that will complete in the future and return a single value or an error.

Example use cases:

Making an API call that returns one response
Reading a file from disk once
Waiting for a delay or timer

Stream

A is used when you expect multiple results over a period of time.

It is like a pipe where data flows continuously, and you can listen to it.

Example use cases:

Receiving real-time updates (like Firebase, WebSocket)
Listening to user input (like text field changes)
Sensor data (like GPS or accelerometer)

46. What is assert used for in Dart and Flutter?

In Dart (and Flutter), is a built-in keyword used for debugging purposes. It helps you catch errors during development by checking whether a condition is . If the condition is , the app will stop (throw an error) and show a message. This only happens in debug mode — not in release mode.

Think of as a guard or checkpoint: it checks your assumptions during code execution.

Why use assert?

Let’s say you’re expecting a variable to never be null, or a number should always be positive. Instead of waiting for a crash or unexpected behavior, you can use to catch it early.

Basic Syntax:

Or with a custom message:

Where is assert commonly used in Flutter?

To validate constructor arguments in widgets:

To ensure that a value passed to a function or class follows a required constraint
During widget tree building to confirm assumptions

47. What is Typedef in Dart?

In Dart, is used to define custom function types. It allows you to give a name to a specific function signature so that you can refer to it more easily, especially when passing functions as parameters or returning functions from other functions.

You can think of it as a shortcut or alias for a function type.

Why use typedef?

When you’re working with functions that accept other functions as arguments (higher-order functions), things can get complicated if the function signatures are long or reused in many places. helps you:

Improve code readability
Reuse complex function signatures
Provide better type safety

48. Can you explain the process of creating custom widgets in Flutter?

In Flutter, creating custom widgets is a fundamental practice that allows you to make reusable, modular, and maintainable components for your UI. Everything in Flutter is a widget, including layout models, buttons, text, and containers. So, by creating custom widgets, you’re essentially making your own building blocks to design screens in a more organized way.

There are two main types of custom widgets in Flutter:

Stateless Widgets
Stateful Widgets

Let’s understand both with detailed explanations and examples.

1. StatelessWidget

A is a widget that does not require any internal state to change during its lifetime. This means once it is built, it won’t rebuild unless its parent widget triggers a rebuild by passing new parameters.

2. StatefulWidget

A is used when the widget needs to maintain a state that may change during the widget's lifetime, such as user input, animation, or API response.

Why create custom widgets?

To improve code readability
To reuse UI components across multiple screens
To keep the methods clean and organized
To follow the principle of separation of concerns

49. What is Stepper in Flutter?

A Stepper is a widget in Flutter that displays a sequence of steps in a linear or vertical format. It is commonly used for forms, onboarding flows, or any process that involves multiple steps where users need to input data or complete actions in a defined order.

Think of it like a checklist or progress flow UI, where users can move step-by-step to complete a task.

How to use Stepper widget:

The widget takes a list of objects and allows you to control navigation between them.

Example:

50. Why do we use a ticker in Flutter?

In Flutter, a Ticker is a special class that signals the passing of time. It’s used primarily to trigger animations or frame-based updates. A ticker calls a callback function on every frame (usually around 60 times per second), giving you a time stamp for how long the animation has been running.

Purpose of a Ticker:

Imagine you want to create a custom animation where something moves smoothly from one place to another. A ticker gives you a precise and consistent stream of updates that you can use to update your UI accordingly.

Summary

Mastering these questions not only helps in interviews but also improves your day-to-day development in Flutter. The key to cracking interviews is understanding the concepts deeply and explaining them clearly with examples.

If you’re preparing for an interview, go beyond memorizing — build small apps to experience these concepts in action.

Thank you for reading. 🙌🙏✌

Found this helpful? Don’t forgot to clap 👏 and follow me for more such useful articles about Flutter, Android development and Kotlin or buy us a coffee here ☕

If you need any help related to Flutter, Android, Kotlin. I’m always happy to help you.

Follow me on:

Medium, Github, Instagram , YouTube & WhatsApp