DEV Community

Cover image for Local State vs External State Management : Comparing State Management in React

Posted on

Local State vs External State Management : Comparing State Management in React


When developing a React application, managing state is one of the crucial tasks. There are primarily two approaches to state management: "Local State" and "External State Management". In this article, we will delve into each approach, explaining them in detail, and consider when to choose one over the other.

Local State

Image description


Local state refers to managing the state within individual components or at a component level. In React, you can use the useState hook to create and manage local state within a functional component, or you can use the this.state object within a class component.

Local state is typically used for managing component-specific data or UI-related state that doesn't need to be shared across the entire application.


  • Simple and easy to understand.
  • Fully encapsulated within a component and does not affect other components.
  • Suitable for small applications and simple components.


  • Difficult to share state between components.
  • Not suitable for large-scale development. (State can be complex).

External State Management

Image description


External state management is in contrast to the local state of a component. Local state is managed within a single component and represents information encapsulated in the component itself. External state management, on the other hand, shares state throughout the application and allows data to be shared among different components.

External state management, on the other hand, refers to a technique for effectively managing data and state that is shared across the entire application.

Major External State Management Tools

Several libraries and tools are available to utilize external state management. Some of the major ones include:

  • Redux
    Redux is a state management library based on the Flux architecture that centrally manages state throughout the application. It uses concepts such as actions, reducers, and stores to control data flow. In addition to plain Redux, a Redux Toolkit with different specifications is also available.

  • Context API
    Built into React, the Context API provides a way to share state within a component tree. It is suitable for small applications and simple cases.

  • Recoil
    Recoil is a relatively new state management library for React applications that manages state using concepts such as atoms, selectors, and routes.

  • Zustand
    Zustand (German word for "state"), like other state management tools, is a library to support state management in React applications. Zustand is a powerful tool to make state management in React applications simple and effective, especially suitable for small to medium-sized projects.

Other External State Managements

Based on my research for this article, it seems that there are various other tools available as well, such as Jotai, Mobx, Valtio, and more. Personally, I hadn't heard of some of them before, but if you're interested, I recommend doing some research on your own.


  • Consistency of State: External state management allows for consistent state management throughout the entire application. This helps maintain data integrity and reduces the occurrence of bugs and inconsistencies.

  • Data Sharing: Data can be shared across multiple components or pages, facilitating effective information sharing and collaboration between components.

  • Suitable for Large-Scale Applications: External state management is particularly well-suited for large-scale applications or complex projects. Centralized state management enhances development efficiency.

  • Integration with Developer Tools: Many external state management tools offer integration with developer tools, enabling state monitoring, debugging, and features like time-travel debugging. As an example, I often use Redux DevTools when using Redux and find them very useful.


  • Setting up external state management tools can be complicated and may require some time to learn. This can be especially challenging for developers who are new to these tools.

  • Overhead: External state management may introduce overhead, compared to smaller projects or simpler components. Overcomplicating state management can lead to decreased development efficiency.

  • Redundancy and Over-Abstraction: Some external state management tools may lead to redundant code or excessive abstraction, potentially making the project more complex than necessary.

  • Performance Concerns: Without proper design and optimization, external state management tools can impact the performance of the application.


The most important point summarized in this article is that local state can be set up easily but its scope is limited to the individual component, whereas external state management requires some setup depending on the specific tool but allows state sharing across the entire application.

Therefore, local state is suitable for small-scale and simple application development, whereas in scenarios where there is frequent state interaction between components or the project becomes more complex, or in larger development environments, adopting external state management becomes valuable.

Image description


In this article, I haven't delved into actual code examples or gone into depth about various external state management tools. If you're interested, I encourage you to explore them on your own (or I may consider writing related articles in the future).

Personally, I had some apprehensions about understanding external state management, so I wrote this article to use it as output in order to further enhance my input and reinforce my understanding. And I hope this article proves helpful to someone who learn state management!

Thank you for reading!

Top comments (0)