Flutter and Dart Interview Questions India 2026: Mobile Development, Widgets, and State Management

Flutter developer salary India (2024-25):

Junior Flutter developer (0-2 years): 5-14 LPA at product companies; 3-6 LPA at service IT. Mid-level Flutter developer (3-5 years): 15-35 LPA at product companies. Senior Flutter developer (5-8 years): 30-60 LPA at product companies.

Flutter vs native Android/iOS: Flutter developers are slightly rarer than native Android developers, giving a small premium in the Indian market. Flutter is a single codebase for iOS, Android, and web, which startups find extremely cost-effective.

Companies hiring Flutter developers in India: Ola (ride-sharing app), CureFit (health and fitness), Doubtnut (edtech), NoBroker, many Series A-C startups targeting mobile-first users in tier-2 cities.

Core Flutter concepts tested in Indian interviews:

1. StatelessWidget vs StatefulWidget: StatelessWidget: immutable; its properties cannot change after the widget is built. Use for UI that does not respond to user interaction or data changes (a logo, a static heading, a fixed list item). StatefulWidget: has mutable state managed by a separate State object; call setState() to trigger a rebuild when state changes. Use for anything that can change based on user input, timers, or API responses.

2. The widget tree: Every Flutter UI is a tree of widgets. The root widget is typically MaterialApp or CupertinoApp. Flutter rebuilds only the parts of the tree that have changed (not the entire screen), making it efficient.

3. Hot reload vs hot restart: Hot reload: applies code changes to the running app without resetting state (variables, navigation stack); fastest for UI iteration. Hot restart: restarts the app from scratch; needed for changes to app state, initialization code, or when adding new packages.

4. Keys in Flutter: Keys help Flutter identify and preserve widget state when widgets are reordered or removed from the tree. Use ValueKey or UniqueKey when reordering a list of StatefulWidgets (each needs a key to preserve its state), or GlobalKey to reference a specific widget programmatically.

5. BuildContext: BuildContext represents the location of a widget in the widget tree. Needed for Navigator.of(context) (navigation), Theme.of(context) (theming), and accessing inherited widgets like Provider or MediaQuery.

Flutter state management is a key interview topic:

Provider (most common, especially at startups): Provider is the officially recommended state management library from the Flutter team. It uses InheritedWidget under the hood. ChangeNotifier + notifyListeners() triggers UI rebuilds. Use Consumer or Provider.of(context) to access state.

Riverpod (growing adoption at product companies): Riverpod is the evolution of Provider, but decoupled from the widget tree. No BuildContext required to access state. StateNotifierProvider, FutureProvider, and StreamProvider cover most use cases. More testable than Provider.

BLoC (Business Logic Component, used at larger companies): BLoC separates business logic from UI using streams. Events flow in, States flow out. The bloc and flutter_bloc packages are the standard. Use BlocBuilder to rebuild UI on new states. BLoC is verbose but very explicit and testable.

GetX: popular at IT services and smaller projects. All-in-one (state, routing, dependency injection). Considered less idiomatic by Flutter purists.

When asked in an interview: explain why you chose your state management solution. 'We used Riverpod because it is fully testable without mocking the widget tree and supports async operations natively via FutureProvider.'

Dart async programming questions:

1. Future: A Future represents a value that will be available in the future (like a Promise in JavaScript). async functions return a Future. Use await to pause execution until the Future resolves. Use try/catch with await to handle errors.

2. Stream: A Stream is a sequence of asynchronous events (like an Observable in RxJS). Use StreamBuilder in Flutter to build UI that reacts to a stream. Common use cases: real-time data (WebSocket, Firebase Realtime Database), file reading, user events.

3. async/await vs .then()/.catchError(): async/await is preferred for readability. .then()/.catchError() is fine for simple one-off futures but gets messy when chaining.

4. Isolates: Dart is single-threaded; Isolates are Dart's version of threads. Use compute() to run a function in a separate isolate (for CPU-heavy operations like JSON parsing of large responses). Communication between isolates happens via SendPort and ReceivePort.

5. Common interview question: 'What is the difference between async and sync in Dart?' async is used to create asynchronous generators that yield values via a Stream. sync is used to create synchronous generators that yield values via an Iterable. Both use yield instead of return.

Flutter animations and performance:

Animation types:

1. Implicit animations: AnimatedContainer, AnimatedOpacity, AnimatedAlign. Flutter handles the tween and animation controller for you. Use for simple property transitions.
2. Explicit animations: AnimationController + Tween + AnimatedBuilder. Full control over the animation curve, duration, and direction. Use for complex, sequenced, or interactive animations.
3. Hero animation: creates a seamless transition of a widget between two routes. Wrap the widget in Hero(tag: 'uniqueTag') on both the source and destination routes.

Performance tips asked in interviews:

1. Use const constructors: if a widget and all its properties are compile-time constants, mark it const. Flutter skips rebuilding const widgets.
2. Avoid rebuilding too many widgets: use setState() at the lowest level in the tree. Use Provider or Riverpod to scope rebuilds to only the consumers that need the data.
3. ListView.builder vs ListView: always use ListView.builder for long or infinite lists (it builds widgets lazily, only when they scroll into view). ListView creates all widgets at once.
4. RepaintBoundary: wraps a widget to isolate it from the rest of the paint layer. Use for complex animated widgets to prevent them from triggering repaints in static siblings.
5. Profile mode: run 'flutter run --profile' to test real performance (debug mode artificially slows down the app with extra assertions).