Flutter interview questions and answers for 2025

A StatefulWidget has mutable state that can change during the widget’s lifetime. It is a built-in Flutter approach to make the UI dynamically update.

Hot reload injects new code into the Dart VM and preserves the current state. Hot restart fully rebuilds the app, resetting all state.

The build() method describes how to display the widget using a tree of other widgets. It’s called every time the UI needs to be updated.

setState() tells Flutter that the state of the widget has changed and the UI should be rebuilt.

final is assigned once at runtime, const is assigned at compile-time and is deeply immutable. Use const for performance where possible.

Use Navigator.push(context, MaterialPageRoute(builder: (_) => LemonScreen())) to push a new route onto the stack.

It builds list items lazily as they scroll into view, which is useful and improves performance for long lists.

FutureBuilder listens to a Future and rebuilds its child based on the connection state (waiting, done, etc.) and the result.

Keys preserve widget state when widgets move or change position in the widget tree. They can be used for example in lists and animations.

Assign a TextEditingController to the TextField to read or manipulate the input. You can also use TextField.onChanged for real-time changes.

It’s a scrollable container for a single widget (like a Column). Use it when the content might overflow vertically.

It’s the configuration file where you declare project metadata, dependencies, fonts, and assets.

It’s the app’s entry point and usually calls runApp(MyApp()) to inflate the widget tree.

Use an ElevatedButton with a custom shape such as RoundedRectangleBorder(borderRadius: ...).

Use Padding(padding: ...) orwrap the widget in a Container with margin/padding properties.

It forces a child of a Row, Column, or Flex to take up all the remaining available space.

It gets the device’s screen dimensions and is useful for responsive design.

MainAxisAlignment aligns children along the main axis (horizontal in Row, vertical in Column), while CrossAxisAlignment aligns them along the cross perpendicular axis.

Column lays out all its children vertically at once (non-scrollable). ListView is scrollable and efficient for long or dynamic content.

A box widget that can include padding, margin, decoration, and constraints. It’s versatile widget used for layout and styling.

It overlays widgets on top of each other. Use it for complex UI, such as banners, image overlays, or when positioning elements freely.

Use showDialog(context: ..., builder: ...) with a widget, such asAlertDialog to display a modal dialog.

Wrap the input fields in a Form widget, assign a GlobalKey<FormState>(), and use formKey.currentState!.validate().

Use Image.network('https://...'), optionally with a loadingBuilder or errorBuilder.

Set the onPressed callback in a TextButton, ElevatedButton, or similar widget.

It adds padding to avoid system UI elements (such as the status bar, notches, etc.), keeping content within safe visible bounds.

It’s called once when the widget is inserted into the widget tree. It is used to initialize data, listeners, or animations.

Use const constructors, Keys, or separate static widgets to isolate rebuilding.

Add the font files to your assets, declare them in pubspec.yaml, and reference them usingTextStyle(fontFamily: '...').

It propagates data down the widget tree efficiently. You create one to share immutable data with descendants widgets, such as themes or localization.

Provider is a dependency injection/state management wrapper. Riverpod is a safer, more testable evolution of Provider. Bloc uses streams and events to manage reactive state.

Extend RenderBox, implement performLayout, paint, and optionally hitTest. It’s used for low-level rendering needs.

The typical lifecycle includes createState() → initState() → didChangeDependencies() → build() → didUpdateWidget() → deactivate() → dispose().

Use const constructors, RepaintBoundary, ValueListenableBuilder, isolate rebuilds, and avoid deep widget nesting.

It follows this structure: Widget → Element → RenderObject. The pipeline runs in phases: layout, paint, compositing and rasterization.

It allows access to a widget’s state across the tree. Downsides include: potential memory leaks and slower widget tree comparisons.

Use a MethodChannel and implement native code in Android (Kotlin/Java) and iOS (Swift/Objective-C).

Use a Timer or a stream transformer like debounceTime() from RxDart.

Isolates run code in parallel without shared memory. Use them for CPU-intensive or long-running tasks to avoid blocking the UI.

Use sqflite, Hive, or ObjectBox for local databases. You can also use shared_preferences for simple key-value storage.

Use flutter_secure_storage (Android Keystore / iOS Keychain) to store sensitive data securely.

Use ListView.builder, cache items, implement a ScrollController with listeners, and load items in batches.

It prevents unnecessary repaints by isolating parts of the widget tree, which helps improve performance.

Use DevTools (Performance tab and Timeline), flutter run --profile, dart:developer, and FlutterFrameTiming.

setState() is scoped to a single widget. ValueNotifier and ChangeNotifier allow more scalable, reactive state management across multiple widgets.

Use Provider, get_it, Riverpod, or custom DI patterns to manage and provide service instances.

Use a centralized state management solution like Riverpod, Bloc, or Redux. Share services or state objects using dependency injection.

Create a MethodChannel, define a contract for the native methods, implement them on Android/iOS, and handle result parsing in Dart.

Flutter uses semantic widgets, labels, and screen reader APIs. Use Semantics widget to expose custom elements to assistive technologies.

min: widget wraps content

max: widget expands to parent’s available space along the main axis.

Widget tree: Immutable configuration.

Element tree: Manages the widget’s lifecycle and state.

RenderObject tree: Handles layout, painting, and hit testing.

The widget might be disposed, which can cause runtime error. Capture the context before the await or check if the widget is still mounted.

Use WidgetTester.pumpAndSettle() or pump(Duration) to simulate animation frames during testing.

Use a ChangeNotifier or ThemeMode, store the user’s theme preference, and rebuild the MaterialApp with the updated ThemeData.

Keys help preserve a widget’s identity across frames, especially useful in implicit animations and transitions.

Use platform-specific plugins like workmanager for Android or background_fetch, and implement native callbacks as needed.

Use ListView.builder with item-specific updates, assign Keys to items, and consider using AnimatedList or SliverChildBuilderDelegate.

Possible solution:

Center(
child: Container(
width: 100.0,
height: 100.0,
color: Colors.red,
);

Possible solution:

List textList(List items) {
return items.map((s) => Text(s)).toList();
}

Possible solution:

Row(
mainAxisAlignment: MainAxisAlignment.spaceEvenly,
children: [
Icon(Icons.home),
Icon(Icons.search),
Icon(Icons.person),
],
);

Possible solution:

class LemonText extends StatefulWidget {
@override
State createState() => _LemonTextState();
}


class _LemonTextState extends State {
final controller = TextEditingController();
String text = '';


@override
void dispose() {
controller.dispose();


super.dispose();
}


@override
Widget build(BuildContext context) {
return Column(
children: [
TextField(
controller: controller,
onChanged: (newText) => setState(() {
text = newText;
}),
),
Text(text),
],
);
}
}

Possible solution:

class ColorCircle extends StatelessWidget {
final Color color;

const ColorCircle({required this.color});

@override
Widget build(BuildContext context) {
return Container(
width: 50.0,
height: 50.0,
decoration: BoxDecoration(color: color,
shape: BoxShape.circle,),
);
}
}

Possible solution:

bool isValidEmail(String email) {
// No need for exact regex, idea is to understand the approach
final regex = RegExp(r'^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$');

return regex.hasMatch(email);
}

Possible solution:

class LemonButton extends StatefulWidget {
@override
_LemonButtonState createState() => _LemonButtonState();
}


class _LemonButtonState extends State {
bool isOn = false;


@override
Widget build(BuildContext context) {
return ElevatedButton(
onPressed: () => setState(() {
isOn = !isOn;
}),
child: Text(isOn ? 'On' : 'Off'),
);
}
}

Possible solution:

ListView.builder(
itemCount: 10,
itemBuilder: (context, index) {
return ListTile(title: Text('Item ${index + 1}'));
},
);

Possible solution:

class LemonAnimatedBox extends StatefulWidget {
@override
State createState() => _LemonAnimatedBoxState();
}


class _LemonAnimatedBoxState extends State {
double size = 100.0;


@override
Widget build(BuildContext context) {
return GestureDetector(
onTap: () => setState(() {
size = size == 100.0 ? 200.0 : 100.0;
}),
child: AnimatedContainer(
duration: Duration(milliseconds: 300),
width: size,
height: size,
color: Colors.blue,
),
);
}
}

Possible solution:

class LemonClockWidget extends StatefulWidget {
@override
State createState() => _LemonClockWidgetState();
}


class _LemonClockWidgetState extends State {
late String time;
late Timer timer;


@override
void initState() {
super.initState();


time = getTime();
timer = Timer.periodic(Duration(seconds: 1), () {
setState(() {
time = _getTime();
});
});
}


@override
void dispose() {
timer.cancel();


super.dispose();
}


@override
Widget build(BuildContext context) {
return Text(time, style: TextStyle(fontSize: 24.0));
}


// Private instance
String _getTime() {
final now = DateTime.now();
    
    return '${now.hour.toString().padLeft(2, '0')}:'
           '${now.minute.toString().padLeft(2, '0')}:'
           '${now.second.toString().padLeft(2, '0')}';
  }
}