27 Jul 2023 · Software Engineering

    Understanding State Management in Flutter (part 1)

    9 min read

    Effective state management is a critical component in the development of any application, particularly in complex applications that contain a significant number of widgets. When working with Flutter, state management specifically pertains to the handling of the widget’s state and its interaction with the user’s actions.

    Flutter provides a range of techniques for effectively managing widget state, with the choice of method dependent on various factors such as the project’s requirements, level of complexity, and personal preferences.

    This article explores the various state management techniques available in Flutter and provides guidance on selecting the most appropriate approach for your project. By the end of this article, you will have the knowledge and tools necessary to make an informed decision regarding the state management pattern that best suits your application’s development needs.


    Before diving into the topic of state management in Flutter, it is essential to have an understanding of the following;

    • Programming basics: fundamental knowledge on programming concepts such as variables, data types, functions, and control structures.
    • Dart programming language: familiarity with Dart syntax, data structures, functions, and object-oriented programming concepts.
    • Flutter: good understanding and experience with Flutter and its widget tre. 
    • Stateful and Stateless widgets: a thorough comprehension of stateful and stateless widgets and when each should be employed.
    • Flutter packages: familiarity with installing and importing Flutter packages and using state management packages like Providers and Redux.

    What is a State

    In Flutter, a state refers to information that defines a widget’s visual appearance and behaviour. Every widget in Flutter has a state associated with it, which can undergo changes throughout the widget’s lifespan.

    Flutter state management

    Flutter offers several techniques for managing the state of the widgets. In this section, we will discuss some of the different state management techniques and when to use them.

    Flutter stateful widget

    A stateful widget is a type of widget in Flutter that can change its appearance and behaviour based on user interactions or other factors. Whenever the state of a stateful widget changes, Flutter rebuilds the widget tree to reflect those changes.

    When you create a stateful widget, Flutter calls the createState() method to create a corresponding State object that manages the state of the widget. The State object updates the widget when the state changes. The stateful widget’s state is private to the widget and cannot be accessed outside of the widget.

    The lifecycle of a stateful widget consists of four stages:

    • createState(): this method is called when the widget is first created to create the associated State object.
    • initState(): this method is called after the widget is created but before it is added to the widget tree. This is where the initialization of the State takes place.
    • build(): this method is called whenever the widget needs to be rebuilt. It is responsible for building the widget tree.
    • dispose(): this method is called when the widget is removed from the widget tree. It is used to dispose of any resources used by the widget.

    Creating a basic application that uses a stateful widget

    Let’s create an example of a stateful widget that displays a counter and increments it when the user taps on the widget.

    import 'package:flutter/material.dart';
    void main() => runApp(MyApp());
    class MyApp extends StatelessWidget {
      const MyApp({super.key});
      // This widget is the root of your application.
      Widget build(BuildContext context) {
        return MaterialApp(
          // Application name
          title: 'Stateful Widget',
          theme: ThemeData(
            primarySwatch: Colors.blue,
          // A widget that will be started on the application startup
          home: CounterWidget(),
    class CounterWidget extends StatefulWidget {
      _CounterWidgetState createState() => _CounterWidgetState();
    class _CounterWidgetState extends State<CounterWidget> {
    //initial couter value
      int _counter = 0;
      Widget build(BuildContext context) {
        return Scaffold(
          appBar: AppBar(
            title: const Text('Stateful Widget'),
          body: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: [
                child: Container(
                  color: Colors.blue,
                  child: Text(
                    //displays the current number
                    style: TextStyle(fontSize: 50.0),
                min: 0,
                max: 100,
                value: _counter.toDouble(),
                onChanged: (double value) {
                  setState(() {
                    _counter = value.toInt();
                activeColor: Colors.blue,
                inactiveColor: Colors.red,

    In the above code, the _CounterWidgetState class is responsible for managing the widget’s state.

    The _counter variable stores the current value of the counter, and when the user moves the slider the value changes.

    The _incrementCounter() method is called to update the counter’s value.

    The setState() method we see there is associated with the stateful widget, and it is responsible for updating the widget’s state, which triggers a rebuild of the widget tree.

    stateful widget full code here

    Factors to consider when choosing a state management technique

    It is important to choose the right state management technique for your project based on your requirements and the complexity of your application.

    To assist in this decision-making process, we will discuss some key factors to consider when selecting a state management technique:

    • Complexity of the Application: the complexity of your application is an important factor to consider when choosing a state management technique. For small and simple applications, using the Flutter Stateful Widget or InheritedWidget may be sufficient. For larger and more complex applications, you may need to use a more advanced technique such as the Provider Package or the BLoC Pattern.
    • Developer Experience: the developer experience is also an important factor to consider. A state management technique like redux may be more familiar to developers with a background in web development, while others may be more familiar to developers with a background in mobile development. It is important to choose a technique that is familiar to your team, and one that allows for efficient development and debugging.
    • Performance: performance is another important factor to consider when choosing a state management technique. Some techniques may introduce unnecessary overhead and slow down your application, while others may be more efficient. It is important to measure the performance of your application using different techniques, and choose the one that provides the best performance.

    Comparison of different state management techniques 

    When choosing a state management technique for your project, it’s important to consider the unique characteristics of each technique and how they fit with your project requirements. Here is a comparison of the different state management techniques:

    State managementDetailsBest forProsCons
    InheritedWidgetThe InheritedWidget class is a fundamental Flutter class that facilitates the transfer of data down the widget tree without the need to pass it as constructor arguments. In scenarios where specific data is necessary further up the widget tree, passing it around as a constructor argument can become tedious and cumbersome, particularly as the app grows in complexity.In such cases, InheritedWidget simplifies the process of data transfer across the widget tree, resulting in reduced code and greater ease of management. For futher details click here: https://github.com/semaphore-community/Justice/blob/feature/new-article-draft/Understanding%20State%20Management%20in%20Flutter/inherited%20widget%20and%20provider.mdSmall to medium-sized projectsSimple and easy to understandLimited reusability and scalability, can lead to prop drilling
    Provider PackageThe Provider package is a state management technique that is built on top of the InheritedWidget class. The Provider package simplifies the use of InheritedWidget by providing a set of widgets that encapsulate the common patterns of using InheritedWidget. For futher details click here: https://github.com/semaphore-community/Justice/blob/feature/new-article-draft/Understanding%20State%20Management%20in%20Flutter/inherited%20widget%20and%20provider.mdMedium to large-sized projectsOffers a range of features for handling state, including dependency injectionStrong reusability and scalability, requires some knowledge of the provider package
    Bloc PatternThe BLoC pattern is a state management approach that promotes a clear separation between the presentation layer (user interface) and business logic layer (data processing and application functionality).By separating these layers, it becomes easier to debug and test the different components of the application. The BLoC design revolves around the concept of having a singular source of truth that houses the application’s current state. For futher details click here: https://github.com/semaphore-community/Justice/blob/feature/new-article-draft/Understanding%20State%20Management%20in%20Flutter/bloC%20and%20redux%20state%20management.mdLarge, complex projectsProvides a clear separation of concerns between the UI and business logic, scalable and maintainableSteep learning curve and can be complex for smaller projects
    Redux PatternThe Redux pattern is a state management pattern that was originally developed for JavaScript applications.The idea behind it was to have only one source that holds all the information about the application’s state, which is kept in a single entity called the store.The store is immutable, meaning that it cannot be modified directly. Instead, actions are sent to the store, which is then handled by reducers.Reducers are functions that take in the current state and an action and then produce a new state as a result. By using this pattern, it becomes easier to think about the state of the application, since there is only one source of truth. For futher details click here : https://github.com/semaphore-community/Justice/blob/feature/new-article-draft/Understanding%20State%20Management%20in%20Flutter/bloC%20and%20redux%20state%20management.mdLarge, complex projects with a lot of stateCentralizes state management and offers a predictable state management system, highly scalable and maintainableSteep learning curve and can be complex for smaller projects


    The use of BLoC and Redux depends on factors such as the size and complexity of your project, the team’s familiarity with the patterns, and personal preferences. Both BLoC and Redux have vibrant ecosystems with extensive community support and numerous packages available. By leveraging the power of these state management patterns, you can build robust and scalable Flutter applications with ease.

    Thank you for reading Part 3 of this series on understanding state management in Flutter. We hope you found the information on BLoC and Redux useful .

    If you’re interested in diving deeper into this topic, check out parts two and three.

    In Part 2, we explore two popular state management approaches called Provider and InheritedWidget. We discuss their features and benefits. You can read it here: Understanding State Management in Flutter (Part 2) .

    Part 3: BloC and Redux State Management

    In Part 3, we conclude the series by discussing some additional state management solutions available in the Flutter ecosystem. We explore alternatives like BLoC and Redux and provide insights into their strengths and use cases. You can read it here: Understanding State Management in Flutter (Part 3).

    Resources for Further Learning:

    Flutter State Management Guide: https://flutter.dev/docs/development/data-and-backend/state-mgmt

    Provider Package Documentation: https://pub.dev/packages/provider

    Bloc Library Documentation: https://bloclibrary.dev/

    Redux Documentation: https://pub.dev/packages/flutter_redux

    Flutter BLoC package: https://pub.dev/packages/flutter_bloc

    Leave a Reply

    Your email address will not be published. Required fields are marked *

    Writen by:
    I'm a mobile developer with a passion for creating pixel-perfect products and interactive user experiences. Additionally, I excel in technical writing, breaking down complex topics into easily understandable bits for individuals at any level.
    Reviewed by:
    I picked up most of my soft/hardware troubleshooting skills in the US Army. A decade of Java development drove me to operations, scaling infrastructure to cope with the thundering herd. Engineering coach and CTO of Teleclinic.