Persistence
Data persistence is the retention of data in storage so it remains available beyond the process or computation that created or changed it.
Java Persistence with Spring Data and Hibernate epub
Persistence is the preservation of data beyond the lifetime of the application process that created or used it.
- How it is used
- Uses persistence to preserve Java objects beyond a process lifetime and store their state in a database.
- How deep it goes
- Explains entity state transitions, cascading, SQL timing, transaction synchronization, and manual flushing.
- Examples
- Demonstrates persisting an Item and cascading persistence from a User to BillingDetails.
- What you can do after
- Apply persistence via JPA EntityManager and Hibernate, accounting for transaction, flush, cascade, and removal behavior.
Read how Java Persistence with Spring Data and Hibernate epub explains persistence →
MongoDB 8.0 in Action, Third Edition
Persistence is the durable storage of program state so that it survives beyond a single program execution.
- How it is used
- Keeps application objects available across program runs and stores processed streaming results in an Atlas collection.
- How deep it goes
- Defines persistence, illustrates document storage, and walks through a streaming write pipeline; does not establish processor-state recovery behavior.
- Examples
- Uses a nested book document, find and update commands, and solar-device aggregates written with `$merge`.
- What you can do after
- Apply it via MongoDB queries to retain and retrieve documents, or via Atlas Stream Processing to store aggregated results.
Read how MongoDB 8.0 in Action, Third Edition explains persistence →
Grokking AI Applications
Persistent storage retains application data across service restarts instead of discarding it when a runtime instance is recreated.
- How it is used
- Supports hosted applications by retaining stored data when their service instances restart.
- How deep it goes
- Defines storage by its survival across restarts without explaining implementation or configuration.
- Examples
- Uses a hosted Langflow instance and a dedicated vector database as storage examples.
- What you can do after
- Understand how persistent storage differs from data wiped when a service restarts.
ASP.NET Core in Action, 3e
Database persistence is the storage of Quartz.NET job and trigger state in a database so it survives application restarts.
- How it is used
- Preserves Quartz.NET job and trigger details across application restarts and can help the scheduler catch up with missed triggers.
- How deep it goes
- Explains configuration, stored state, manual table setup, and database-lock coordination, but gives no full database-schema walkthrough.
- Examples
- Uses AddQuartz() with UsePersistentStore(), SQL Server, JSON serialization, and optional clustering as the configuration example.
- What you can do after
- Configure Quartz.NET persistence with UsePersistentStore(), choose a database, and optionally coordinate schedulers with UseClustering().
Elixir in Action, Third Edition
Data persistence is the retention of data beyond the lifetime of the computation that created or processed it.
- How it is used
- Supports recovery and availability in concurrent systems by retaining state across process lifetimes.
- How deep it goes
- Explains disk and ETS implementations, write timing, restart behavior, and performance boundaries without detailing storage internals.
- Examples
- Uses a persistent to-do cache, Erlang external term encoding, post-update storage, and ETS table operations.
- What you can do after
- Build it from scratch with disk storage or ETS, then evaluate consistency, restart safety, latency, and distribution trade-offs.
Read how Elixir in Action, Third Edition explains persistence →
Designing Deep Learning Systems: A guide for software engineers
The retention of data across process executions and system interactions so that it remains available for later retrieval.
- How it is used
- Supports reproducible dataset delivery from data collection through model training.
- How deep it goes
- Defines layered storage, immutable commits, versioned snapshots, hashes, and deletion policy, while deferring full management implementation.
- Examples
- Uses immutable dataset commits, versioned training snapshots, version hashes, cloud object storage, Delta Lake, Petastorm, and Pachyderm.
- What you can do after
- Operate a dataset workflow that retrieves reproducible training inputs and preserves update history for troubleshooting.
Read how Designing Deep Learning Systems: A guide for software engineers explains persistence →
Kubernetes in Action, Second Edition
Data persistence is the preservation of data so that it remains available across process or container termination and recreation.
- How it is used
- Supports application deployment when stored data must outlive the pods using it.
- How deep it goes
- Explains the motivation and Kubernetes storage model, then surveys provisioning, snapshots, cloning, restoration, and lifecycle variants.
- Examples
- Uses a Quiz API, MongoDB, a pod manifest, curl requests, mongosh commands, and a shutdown test showing data loss.
- What you can do after
- Evaluate why a database loses data without persistent storage and how Kubernetes abstracts storage requirements.
Read how Kubernetes in Action, Second Edition explains persistence →
Kafka for Architects
Message persistence is the durable storage of messages beyond the lifetime of the process that produced or consumed them.
- How it is used
- Preserves Kafka messages across broker failures or consumer disconnections and enables later delivery or replay.
- How deep it goes
- Defines broker storage, replication, retention, and consumer recovery, without detailing storage internals.
- Examples
- Uses broker failure and disconnected consumers to illustrate recovery, and contrasts retention expiry with acknowledgment-based deletion.
- What you can do after
- Operate/configure retention to match application needs, monitor disk use, and account for expiry regardless of processing.
AI Agents in Action, Second Edition
Persistence is the continuation of a system's goal-directed operation across multiple steps or interactions.
- How it is used
- Extends agent work beyond a single interaction by carrying goal-directed operation across multiple steps.
- How deep it goes
- Explains external plan and state storage, but leaves production memory operations to additional design work.
- Examples
- Uses long-horizon research and a revised San Francisco itinerary to illustrate continuing work.
- What you can do after
- Understand how external plans and state let an agent coordinate work across short cycles toward a long-term goal.
Read how AI Agents in Action, Second Edition explains persistence →
Microservices Patterns, Second Edition
Message persistence is the storage of messages so they survive broker crashes or restarts.
- How it is used
- Evaluates whether messages must survive broker crashes when selecting technology for each message channel.
- How deep it goes
- Defines persistence as survival across broker crashes, but does not describe storage mechanisms or broker-specific configuration.
- What you can do after
- Evaluate broker choices by deciding whether each channel must retain messages through broker crashes.
Read how Microservices Patterns, Second Edition explains persistence →
Introduction to Generative AI, Second Edition
Persistent state is information about an application or agent that remains available across operations or interactions.
- How it is used
- Carries past actions, goals, and context across agent sessions to support continuity, planning, and coordination.
- How deep it goes
- Defines persistent state and explains memory corruption, privacy exposure, and attack pathways without implementation detail.
- Examples
- Uses a Discord memory-poisoning attack that led an agent to make a fraudulent financial transfer.
- What you can do after
- Understand how retained agent information can support continuity while enabling manipulation, privacy exposure, and harder-to-contain failures.
Read how Introduction to Generative AI, Second Edition explains persistence →
Spring Start Here, Second Edition
Persistence is the retention of application data beyond the lifetime of the process that created it.
- How it is used
- Uses persistence as a backend-application capability for managing data in databases.
- How deep it goes
- Describes persistence as a backend capability but stops short of explaining implementation details.
- Examples
- Uses backend applications that manage data in databases as the practical example.
- What you can do after
- Apply persistence by connecting a Spring application to a database and working with persisted data.
Read how Spring Start Here, Second Edition explains persistence →
Also covered in
- A Pythonic Adventure: From Python basics to a working web app
- Server-Side WebAssembly
- Practices of the Python Pro
- Test Driven: Practical TDD and Acceptance TDD for Java Developers
- Akka in Action, Second Edition
- Python Concurrency with asyncio
- AI GovernanceIn early access (MEAP)
- Quarkus in Action
- Learn Docker in a Month of Lunches, Second Edition
- Build an AI Agent (From Scratch)
- Spring in Action, Sixth Edition
- Architecting AccessibilityIn early access (MEAP)
What to know first
- MapA map is an associative data structure that stores key-value associations and supports retrieving values by key.
- containerA software container is an isolated execution environment that packages an application and its dependencies, typically sharing the host operating-system kernel.
- distributed systemA distributed system is a computing system whose components run across multiple networked processes or machines and coordinate through communication.
- JSONJSON is a language-independent text-based data-interchange format that represents structured values using objects, arrays, strings, numbers, booleans, and null.
Related concepts
- entity stateproduces · An entity state is a persistence-related condition describing how an entity instance is associated with a persistence context and database.
- NoSQL databaseused by · A NoSQL database is a database system organized primarily around nonrelational data models rather than the traditional relational table model.
- state managementused by · State management is the practice of organizing, maintaining, and updating information that represents a system’s or process’s condition over time.
- databasealternative to · A database is an organized persistent data store, typically managed by software, that supports storing, retrieving, and modifying data.
- Apache Kafkaused by · Apache Kafka is a distributed event-streaming platform for publishing, storing, and processing streams of records.
Questions about persistence
What is persistence?
Data persistence is the retention of data in storage so it remains available beyond the process or computation that created or changed it.
Which Manning books explain persistence?
Java Persistence with Spring Data and Hibernate epub, MongoDB 8.0 in Action, Third Edition, Grokking AI Applications, ASP.NET Core in Action, 3e, Elixir in Action, Third Edition, Designing Deep Learning Systems: A guide for software engineers, Kubernetes in Action, Second Edition, Kafka for Architects and 4 more.
What should I know before learning persistence?
Manning books that teach persistence usually introduce Map, container, distributed system and JSON first.
What is the difference between persistence and redis pub/sub?
Data persistence is the retention of data in storage so it remains available beyond the process or computation that created or changed it. Redis's publish/subscribe messaging functionality, which lets publishers send messages to channels and subscribers receive messages from those channels.
What is persistence also called?
Persistence is also called persisting.
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.











