Flutter Developer Interview Questions India 2026: Widgets, State Management, and Cross-Platform

Flutter core concepts:

1. What is Flutter? Flutter is Google's UI toolkit for building natively compiled applications for mobile (iOS and Android), web, and desktop from a single Dart codebase. Flutter does not use native UI components; it renders every pixel itself using the Skia (or Impeller on newer versions) rendering engine. This gives Flutter pixel-perfect consistency across platforms and removes dependence on native UI component behaviour.

2. Dart basics: Dart is a strongly typed, compiled language (both AOT-compiled for production and JIT-compiled for hot reload). Key concepts: null safety (Dart 2.12+; ? for nullable, ! for null assertion, late for late-initialised non-nullable variables), async/await (identical pattern to JavaScript/Swift), mixins (a way to reuse a class's members in multiple class hierarchies without traditional inheritance), extension methods (add new methods to existing types without modifying them).

3. Widget tree: Everything in Flutter is a widget. The widget tree is a tree of immutable objects that describes the UI. StatelessWidget: immutable; the build() method is a pure function of the constructor arguments. StatefulWidget: has mutable state (managed by a separate State object); call setState() to trigger a rebuild. Flutter rebuilds only the widgets in the subtree that changed. BuildContext: a handle to the widget's location in the widget tree; used to access theme, MediaQuery, and inherited widgets.

4. Hot reload and hot restart: Hot reload: injects updated source code into the running Dart VM and rebuilds the widget tree from the current state. Changes to build methods appear instantly without losing app state. Hot restart: restarts the app from scratch (resets state); slower than hot reload but handles structural code changes. Both are only available in debug mode.

Flutter state management:

1. setState (local state): The simplest state management: call setState(() { counter++; }) inside a StatefulWidget's State class. Only suitable for local, component-level state that does not need to be shared between widgets.

2. Provider (Google's recommended): Provider is a Flutter package that uses InheritedWidget to propagate state down the widget tree and notify listeners when it changes. ChangeNotifier: a class that can notify its listeners when data changes; use notifyListeners() to trigger a rebuild. ChangeNotifierProvider: puts a ChangeNotifier into the widget tree. Consumer / context.watch(): rebuild when the ChangeNotifier changes. Provider is simple, Flutter team-backed, and suitable for most apps.

3. Riverpod: Riverpod is a re-architecture of Provider by the same author. It fixes Provider's limitations: Riverpod providers can be accessed from anywhere without a BuildContext, are lazily loaded, and have compile-time safety. Widely adopted in Indian Flutter teams for new projects as of 2024.

4. BLoC (Business Logic Component): BLoC separates business logic from UI. Events: what happens (UserLoggedIn, FetchOrdersRequested). States: the result (LoggedIn, OrdersFetched, OrdersFetchError). Bloc: takes events, processes them, emits states. The flutter_bloc package provides BlocProvider, BlocBuilder, BlocListener. BLoC is verbose but very testable (pure event-in, state-out logic with no side effects). Widely used in large Flutter apps at Indian companies.

5. GetX: GetX is an all-in-one state management + dependency injection + navigation solution. Very minimal boilerplate. Controversial in the Flutter community (the package does too many things; makes it harder to follow standard patterns). Used at many Indian Flutter teams that value speed of development.

Flutter production topics:

1. Flutter rendering pipeline: Every frame goes through three trees: Widget tree (lightweight, immutable descriptions of UI), Element tree (mutable; tracks widget lifecycle; mediates between Widget and RenderObject), RenderObject tree (actual layout and painting; expensive to create; reused across rebuilds when possible). The key to Flutter performance: keep the widget tree shallow; avoid unnecessary rebuilds (use const constructors for widgets that never change; separate StatefulWidget sub-trees to isolate rebuilds).

2. FlatList equivalent (ListView.builder): ListView.builder: lazy-loading list that only builds widgets that are currently visible; the Flutter equivalent of React Native's FlatList or Android's RecyclerView. ListView vs ListView.builder: ListView builds all children upfront (only for very short lists); ListView.builder is lazy (for long lists).

3. Platform channels: Platform channels allow Flutter Dart code to call native Android (Kotlin/Java) or iOS (Swift/Objective-C) code. MethodChannel: invoke a native method and get a result (one-shot call). EventChannel: continuous stream of events from native to Flutter (e.g., sensor data, Bluetooth events). When to use: Flutter does not have a plugin for a native capability (e.g., accessing a device's proprietary hardware API).

4. Flutter testing: Unit tests: test Dart code without Flutter (pure Dart logic, BLoC, repositories). Widget tests: test individual widgets in isolation using WidgetTester; fluttertest package; pumps the widget tree and simulates interactions. Integration tests: test the entire app on a real device or emulator using flutterintegration_test. Golden tests: snapshot-based visual regression tests (captures a screenshot and compares it to a golden file).

Flutter navigation and deployment:

1. Navigation: Navigator 1.0 (push/pop): Navigator.push(context, MaterialPageRoute(builder: () => DetailScreen())). Simple but does not handle deep links or complex routing well. Navigator 2.0 (Router): declarative routing; maps URL to a page stack; required for web and deep link support. gorouter package: the recommended package for Flutter navigation (handles deep links, named routes, URL parameters, nested navigation). In practice: most Indian Flutter teams use go_router.

2. Deep links: Deep links allow external URLs to navigate to specific screens in the Flutter app. Android: intent filters in AndroidManifest.xml. iOS: URL schemes in Info.plist or Universal Links (apple-app-site-association). Flutter: go_router handles deep link routing by mapping URL patterns to screens.

3. Releasing a Flutter app: Android: flutter build apk (split per ABI for smaller downloads) or flutter build appbundle (recommended for Google Play; Play automatically serves the right APK). iOS: flutter build ipa. Obfuscation: flutter build apk --obfuscate --split-debug-info (minifies and obfuscates the Dart code; generates symbols for crash symbolication).

4. Flutter vs React Native in Indian job interviews: Flutter interviews tend to ask more about Dart (null safety, async patterns, isolates for background computation) and the widget lifecycle. React Native interviews focus more on JavaScript/TypeScript, bridge/JSI, and React patterns. Both require knowledge of state management, navigation, and native platform integration. Companies that use both in India: some companies (Groww, Urban Company) have both Flutter and React Native apps for different surfaces.