State management
State management is the practice of organizing, maintaining, and updating information that represents a system’s or process’s condition over time.
Build a Frontend Web Framework (From Scratch)
A state manager is a software mechanism that stores application state, processes state changes, and coordinates updates to dependent views.
- How it is used
- Keeps application state and the rendered view synchronized as user interactions produce commands.
- How deep it goes
- Builds dispatcher subscriptions, reducer updates, and re-rendering; defers selective DOM updates and skips checking whether every command changed state.
- Examples
- Uses TODO interactions and a removeTodo reducer, with a counter exercise for choosing commands.
- What you can do after
- Build it from scratch by wiring command-specific reducers to stored state and an after-command renderer.
Read how Build a Frontend Web Framework (From Scratch) explains state management →
Build AI-Enhanced Web Apps
State management is the organization, storage, and updating of application state over time.
- How it is used
- Maintains conversational context and responsive interfaces across client and server state.
- How deep it goes
- Explains hook design, provider setup, synchronization, persistence trade-offs, and logging for state problems.
- Examples
- Uses a chat submission hook, a profile and settings provider, and persistent interview sessions.
- What you can do after
- Apply it via React hooks and the Vercel AI SDK to manage chat and shared application state.
Read how Build AI-Enhanced Web Apps explains state management →
Acing the Frontend Interview
State management is the organization, storage, updating, and propagation of an application's changing data and UI state.
- How it is used
- Frames state management as an interview competency for designing maintainable, performant React data flows.
- How deep it goes
- Explains one-way flow, lifting state, prop drilling, Context API, hooks, libraries, and context re-render concerns.
- Examples
- Uses nested TypeScript components for prop drilling and a Context provider with useContext as the alternative.
- What you can do after
- Apply state-management patterns, explain their trade-offs in interviews, and select native or third-party approaches for shared state.
Read how Acing the Frontend Interview explains state management →
Modern Angular
State management is the practice of storing, updating, and sharing application state across software components.
- How it is used
- Centralizes shared feature data and behavior so multiple Angular components can consume reactive state.
- How deep it goes
- Works through a signal-and-RxJS service implementation, including derived request state, event streams, and component delegation.
- Examples
- Uses authentication status and an HR time-off workflow with filtering, approval, rejection, deletion, and a TimeOffManagementComponent.
- What you can do after
- Build it from scratch as a lightweight signal-based service that handles event streams and exposes shared reactive state.
Building Reliable AI Systems
State management is the handling and maintenance of an application's current state as it executes and responds to interactions.
- How it is used
- Coordinates shared context across specialized agents so their work survives workflow steps and reaches response synthesis.
- How deep it goes
- Defines shared state and its role in routing and coordination without specifying a state schema or update mechanism.
- Examples
- Uses a shopping assistant that combines image analysis, product search, and return-policy retrieval for one customer request.
- What you can do after
- Evaluate multi-agent workflows for state continuity, coordination, and failure handling.
Read how Building Reliable AI Systems explains state management →
Software Testing with Generative AI
State management is the control and maintenance of the system conditions required for an operation or test.
- How it is used
- Uses APIs, databases, test-data managers, or infrastructure tools to establish test conditions at an appropriate layer.
- How deep it goes
- Demonstrates request capture, prompt constraints, POJO modeling, and API setup, but omits HTTP-response parsing.
- Examples
- Uses a Contact Us message, a captured curl command, a Java MessagePayload, and an Admin-panel visibility check.
- What you can do after
- Apply it via API calls and Spring-based Java helpers to make UI checks faster and less brittle.
Read how Software Testing with Generative AI explains state management →
Build Python Web Apps with Streamlit
State management is the practice of retaining and updating application data that determines behavior across interactions or executions.
- How it is used
- Uses state management to preserve a quiz game's progress across Streamlit reruns.
- How deep it goes
- Defines a stateful Game object, session storage, current values, and status-driven branches; defers persistent storage.
- Examples
- Demonstrates Fact Frenzy through question retrieval, answer submission, evaluation, and result display.
- What you can do after
- Apply it via Streamlit to preserve a Game instance and move a quiz through sequential states.
Read how Build Python Web Apps with Streamlit explains state management →
React in Depth
The organization, updating, and synchronization of data representing an application's current state.
- How it is used
- Frames state management as a React ecosystem concern used to select libraries appropriate to project needs.
- How deep it goes
- Compares library choices across project scenarios but stops short of implementation mechanics and state-update internals.
- Examples
- Uses RTK, Zustand, and Redux in e-commerce, portfolio, and legacy enterprise-dashboard stack scenarios.
- What you can do after
- Evaluate state-management libraries and choose a project-fit stack for complex React applications.
AI Agents and Applications
State management is the controlled maintenance and updating of information representing a workflow's current condition across its processing steps.
- How it is used
- Coordinates data across multi-step LangGraph workflows that branch, repeat, preserve context, and support debugging.
- How deep it goes
- Defines TypedDict state, node updates, graph routing, and accumulated execution history, without detailing storage or persistence internals.
- Examples
- Uses a typed research assistant whose search loop evaluates summary relevance before refining queries or writing a final report.
- What you can do after
- Build it from scratch with TypedDict, StateGraph, node functions, directed edges, and conditional routing.
Read how AI Agents and Applications explains state management →
Architecting an Apache Iceberg Lakehouse
State management is the persistence, tracking, and restoration of intermediate processing state in a long-running data workflow.
- How it is used
- Supports reliable recovery and context-aware processing in long-running streaming ingestion pipelines.
- How deep it goes
- Explains persistence, checkpoint-based recovery, transactional completion, and commit tradeoffs without detailing checkpoint implementation.
- Examples
- Uses deduplication, sessionization, and change data capture as stateful transformation examples.
- What you can do after
- Operate streaming recovery with Apache Flink checkpointing and transactional table commits.
Read how Architecting an Apache Iceberg Lakehouse explains state management →
Also covered in
- AI Agents in Action, Second Edition
- HTML5 in Action
- Type-Driven Development with Idris
- The Well-Grounded Rubyist, Fourth Edition
- Systems Programming with ZigIn early access (MEAP)
- AI Agents for Offensive SecurityIn early access (MEAP)
- Vanilla WebIn early access (MEAP)
- Building Web APIs with ASP.NET Core
- Designing AI AgentsIn early access (MEAP)
- Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
- Context EngineeringIn early access (MEAP)
What to know first
- stateState is information describing the condition or configuration of a system or computation at a particular time that may influence its behavior or subsequent transitions.
- Document Object ModelThe Document Object Model is a platform-independent programming interface that represents a document as a structured tree of nodes and provides ways to access and modify its content and structure.
- dialogueDialogue is an ordered exchange of related messages across successive turns between participants or an interactive system and its users.
- JavaScriptJavaScript is a high-level, dynamically typed programming language standardized as ECMAScript and used for web and general-purpose programming.
Related concepts
- LangGraphused by · LangGraph is a framework for building stateful, graph-structured workflows and applications, including those involving language models and agents.
- persistenceuses · Data persistence is the retention of data in storage so it remains available beyond the process or computation that created or changed it.
- api calluses · An API call is a programmatic request or invocation sent through an application programming interface to retrieve data or invoke an exposed operation.
- frameworkused by · A software framework is a reusable foundation of components, conventions, and supporting mechanisms that structures application development and provides common functionality and extension points.
- stateuses · State is information describing the condition or configuration of a system or computation at a particular time that may influence its behavior or subsequent transitions.
- reduction operationuses · A reduction operation combines multiple input values according to a rule to produce fewer results, often a single aggregate.
Questions about state management
What is state management?
State management is the practice of organizing, maintaining, and updating information that represents a system’s or process’s condition over time.
Which Manning books explain state management?
Build a Frontend Web Framework (From Scratch), Build AI-Enhanced Web Apps, Acing the Frontend Interview, Modern Angular, Building Reliable AI Systems, Software Testing with Generative AI, Build Python Web Apps with Streamlit, React in Depth and 2 more.
What should I know before learning state management?
Manning books that teach state management usually introduce state, Document Object Model, dialogue and JavaScript first.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.









