Flutter State Management and Architecture Interview Questions for Mobile App Development

Show answer

setState works for local UI state inside one widget, but shared state like the logged-in user, cart or settings must be read and changed by many screens. Passing it through constructors becomes messy, and rebuilding large trees hurts performance. State management libraries separate business logic from UI, make state testable, rebuild only widgets that depend on changed data, and give a clear, predictable flow of updates.

How do you handle navigation in Flutter with go_router?

Show answer

go_router is a declarative, URL-based routing package maintained by the Flutter team. You define GoRoute entries with paths like /product/:id, navigate with context.go or context.push, and read parameters from state.pathParameters. It supports nested navigation with ShellRoute for bottom tabs, redirects for authentication guards, and deep links on mobile and web. It wraps the Router API, which is complex to use directly.

How do you handle app-wide theming and dark mode in Flutter?

Show answer

Define ThemeData for light and dark modes in MaterialApp, using ColorScheme.fromSeed to generate consistent Material 3 colours, and set themeMode from a settings state, saved in shared preferences. Widgets read Theme.of(context).colorScheme and textTheme instead of hardcoded colours. Add ThemeExtension classes for brand-specific tokens. This keeps the design consistent and makes switching themes a single state change.

How do you explain your architecture choices to a new team member?

Show answer

I start with the problem each layer solves, using one real feature from our app to trace a user tap through widget, state notifier, repository and API, and back to the UI. I share a short diagram and the team's architecture document, then give them a small task touching every layer. I review their first pull request closely and invite questions so they understand the reasons, not only the rules.

What is InheritedWidget and how does Provider build on it?

Show answer

InheritedWidget lets descendants read data efficiently via context and rebuild when it changes, which is how Theme and MediaQuery work. Writing it by hand is verbose. Provider wraps InheritedWidget with a simpler API: ChangeNotifierProvider exposes a ChangeNotifier, and widgets use context.watch to rebuild or context.read to call methods without rebuilding. It is simple and suitable for small to medium apps.

Compare Provider, Riverpod and Bloc.

Show answer

Provider is simple and built on InheritedWidget but depends on BuildContext and can throw provider-not-found errors at runtime. Riverpod, from the same author, is compile-safe, independent of the widget tree, supports async providers and easy overrides for testing. Bloc uses events and states with streams, enforcing strict separation and traceability, popular in large teams and enterprises. Choose based on team familiarity and app complexity.

Explain the Bloc pattern and Cubit.

Show answer

In Bloc, the UI adds events, the Bloc handles them with on<Event> handlers and emits new immutable states, and widgets rebuild with BlocBuilder or react with BlocListener. A Cubit is a simpler version where the UI calls methods directly and the Cubit emits states, without event classes. Use Cubit for straightforward logic and full Bloc when you need event transformations like debounce or detailed traceability.

Write a Cubit that loads products and emits loading, success and error states.

Show answer

sealed class ProductState {} class ProductLoading extends ProductState {} class ProductLoaded extends ProductState { ProductLoaded(this.items); final List<Product> items; } class ProductError extends ProductState { ProductError(this.message); final String message; } class ProductCubit extends Cubit<ProductState> { ProductCubit(this._repo) : super(ProductLoading()); final ProductRepository _repo; Future<void> load() async { emit(ProductLoading()); try { emit(ProductLoaded(await _repo.fetchProducts())); } catch (_) { emit(ProductError('Could not load products')); } } }

Write a Riverpod provider that fetches data asynchronously and display it in a widget.

Show answer

final productsProvider = FutureProvider.autoDispose<List<Product>>((ref) { final repo = ref.watch(productRepositoryProvider); return repo.fetchProducts(); }); class ProductsView extends ConsumerWidget { const ProductsView({super.key}); @override Widget build(BuildContext context, WidgetRef ref) { final products = ref.watch(productsProvider); return products.when( loading: () => const Center(child: CircularProgressIndicator()), error: (e, _) => const Center(child: Text('Failed to load')), data: (items) => ListView(children: [for (final p in items) ListTile(title: Text(p.name))]), ); } }

What is clean architecture in a Flutter app?

Show answer

Clean architecture separates code into presentation (widgets and state notifiers or blocs), domain (entities, use cases and repository interfaces) and data (repository implementations, API clients, local storage and DTOs). Dependencies point inward, so the domain knows nothing about Flutter or HTTP. It improves testability and lets you swap data sources. For small apps it may be heavy, so many teams keep presentation and data layers and add domain only when logic grows.

Write a go_router configuration with an auth redirect.

Show answer

final router = GoRouter( initialLocation: '/', refreshListenable: authNotifier, redirect: (context, state) { final loggedIn = authNotifier.isLoggedIn; final goingToLogin = state.matchedLocation == '/login'; if (!loggedIn && !goingToLogin) return '/login'; if (loggedIn && goingToLogin) return '/'; return null; }, routes: [ GoRoute(path: '/', builder: (_, __) => const HomePage()), GoRoute(path: '/login', builder: (_, __) => const LoginPage()), GoRoute( path: '/product/:id', builder: (_, state) => ProductPage(id: state.pathParameters['id']!), ), ], );

What is dependency injection in Flutter and how is it done?

Show answer

Dependency injection supplies objects like API clients and repositories from outside instead of creating them inside widgets or blocs. In Flutter it is commonly done with Riverpod providers, Provider or RepositoryProvider in Bloc, or a service locator like get_it, sometimes with injectable for code generation. It makes code testable because tests can override dependencies with fakes, and it centralises object lifetimes.

What is the freezed package used for?

Show answer

freezed generates immutable data classes with copyWith, equality, toString and union types or sealed classes, and integrates with json_serializable for fromJson and toJson. It removes boilerplate when modelling state such as loading, data and error variants. You annotate a class, run build_runner, and get generated code in a part file. With Dart 3 sealed classes and records, some teams need it less, but it is still widely used.

How would you test a Bloc or Riverpod notifier?

Show answer

Test business logic without widgets. For Bloc, the bloc_test package's blocTest builds the bloc with a fake repository, acts by adding events, and expects a list of emitted states. For Riverpod, create a ProviderContainer with overrides for repository providers, read the notifier, call methods and assert the state. Use mocktail for mocks and keep tests fast, deterministic and independent of the network.

The cart total shows stale values on the checkout screen after items are removed on the cart screen. How do you fix it?

Show answer

Each screen probably holds its own copy of cart data. Move cart state into a single shared state object, such as a Riverpod notifier or a Cubit provided above both screens, and have both screens watch it. All mutations go through that object, which emits a new immutable state. Derived values like total should be computed from the state, not stored separately, so they can never become inconsistent.

Your Flutter codebase mixes setState, Provider and get_it randomly across screens. How would you clean it up?

Show answer

Agree on one approach with the team, for example Riverpod for app state and setState only for local widget state, and document examples. Migrate gradually, starting with the most buggy or most changed features, and write tests before moving logic. Add lint rules and pull request checklists so new code follows the standard. Avoid a big-bang rewrite that blocks feature work for weeks.

How do you manage form state and validation across multiple steps in a Flutter onboarding flow?

Show answer

Keep the onboarding data in one state object owned by a notifier or cubit scoped to the flow, with each step updating its part. Validate per step before moving forward and again on final submit. Save progress locally so users can resume if they leave. Keep validation rules in pure functions that are unit tested. Dispose the state when the flow completes so data does not leak into later sessions.

What is the difference between ref.watch, ref.read and ref.listen in Riverpod?

Show answer

ref.watch subscribes to a provider and rebuilds the widget or recomputes the provider when it changes; use it in build methods. ref.read gets the current value once without subscribing; use it in callbacks like onPressed to call notifier methods. ref.listen runs a callback when a provider changes without rebuilding, useful for side effects like showing a snackbar or navigating after a state change.

Tell me about a technical decision you made that you later regretted, and what you learned.

Show answer

Situation: on an earlier project I chose a lesser-known state management package because it looked simpler. Task: support the app as it grew. Action: when the package stopped being maintained, I led a migration to Riverpod feature by feature with tests. Result: the migration took three sprints. I learned to evaluate packages by maintenance activity, community size and testing support, not just initial simplicity, and to document decisions.

How do you avoid unnecessary rebuilds in a Flutter app with state management?

Show answer

Rebuild only what depends on the changed data. Use selectors such as context.select, ref.watch(provider.select(...)) or BlocSelector to listen to one field, split big widgets into smaller ones, and use const constructors. Keep state objects immutable with proper equality so identical states do not trigger rebuilds. Use Flutter DevTools rebuild tracking to find widgets that rebuild more often than expected.

A Bloc emits the same state twice and the UI does not update. Why?

Show answer

Bloc and Cubit skip emitting a state that is equal to the current one. If you mutate a list inside the existing state and emit the same object, equality holds and nothing rebuilds. Always emit a new state with copied collections, for example state.copyWith(items: [...state.items, newItem]), and implement equality with Equatable or freezed. Avoid mutable fields in state classes.

How do you handle a logout that must clear all user data across the app?

Show answer

Centralise session state in an auth provider or bloc that other state depends on. On logout, clear secure tokens, wipe local databases or caches for that user, reset or invalidate dependent providers, for example by Riverpod providers watching the auth state, and redirect with the router guard to login. Cancel ongoing requests and background jobs. Test that no previous user's data appears after logging in as someone else.

The app needs a bottom navigation bar where each tab keeps its own navigation history. How do you implement it?

Show answer

Use go_router's StatefulShellRoute.indexedStack, which creates a separate navigator branch for each tab and keeps their stacks alive with an IndexedStack. The scaffold shows a NavigationBar and switches branches with navigationShell.goBranch(index). This preserves scroll positions and nested pages when switching tabs, and deep links can open a specific tab and page. Handle tapping the active tab to pop to its root.

You are designing a large Flutter app for a bank with 30 developers. How do you structure it?

Show answer

Split the app into feature packages in a monorepo managed with Melos or pub workspaces, plus core packages for networking, design system, analytics and security. Pick one state management approach, such as Bloc for strict traceability, with clear layer boundaries. Use code generation consistently, enforce lints and architecture tests in CI, and assign feature ownership. Add integration tests for critical journeys and strict security reviews for storage and network code.

Users lose their place in a long Flutter form when they get a phone call and the app is killed in background. How do you fix it?