ACID
ACID is the set of database transaction properties—atomicity, consistency, isolation, and durability—that characterize reliable transactional behavior.
Grokking Software Architecture
A database transaction that provides atomicity, consistency, isolation, and durability guarantees.
- How it is used
- Uses transaction guarantees to explain data integrity and the consistency challenge across distributed services.
- How deep it goes
- Defines all four guarantees through a transaction scenario, without detailing their implementation.
- Examples
- Illustrates a last-sneaker purchase with inventory updates, order creation, rollback, and an overselling constraint.
- What you can do after
- Evaluate how transaction guarantees protect a purchase and why distributed services need other consistency patterns.
100 SQL Server Mistakes and How to Avoid Them
ACID is a set of transaction properties requiring atomicity, consistency, isolation, and durability.
- How it is used
- Frames reliable T-SQL error handling around transactions that must commit or roll back as one unit.
- How deep it goes
- Defines all four properties and relates isolation and durability to locking, logging, isolation levels, and delayed durability.
- Examples
- Uses a failing sales-order procedure, a renamed details table, foreign-key violations, and @@TRANCOUNT to expose an unclosed transaction.
- What you can do after
- Diagnose/debug with @@TRANCOUNT and apply rollback-oriented error handling to failed T-SQL transactions.
Read how 100 SQL Server Mistakes and How to Avoid Them explains ACID →
Building Web APIs with ASP.NET Core
ACID is a set of transaction properties—atomicity, consistency, isolation, and durability—that define reliable behavior for database transactions.
- How it is used
- Frames database transactions as reliable behavior and guides DbContext usage around a unit of work.
- How deep it goes
- Defines the four properties and connects them to DbContext usage, without detailing each property’s internal implementation.
- Examples
- Uses board-game reads and a mechanics-wide rename as concrete transaction scenarios.
- What you can do after
- Apply it via DbContext lifetimes to organize database work within a unit of work.
Read how Building Web APIs with ASP.NET Core explains ACID →
Microservices Patterns, Second Edition
A database transaction that provides atomicity, consistency, isolation, and durability guarantees.
- How it is used
- Provides a correctness boundary for system commands that change state.
- How deep it goes
- Defines transaction boundaries, commit and abort behavior, concurrency conflicts, and local-versus-distributed trade-offs.
- Examples
- Uses a product lookup, customer-credit update, and order insertion as a transaction example.
- What you can do after
- Apply ACID transactions to service-local operations and choose sagas for operations spanning services.
Read how Microservices Patterns, Second Edition explains ACID →
Architecting an Apache Iceberg Lakehouse
The transaction guarantees of atomicity, consistency, isolation, and durability that preserve reliable database state changes.
- How it is used
- Secures shared analytical table updates when multiple jobs, readers, and tools operate concurrently.
- How deep it goes
- Defines all four guarantees and their commit behavior, but stops short of specifying lower-level implementation algorithms.
- Examples
- Uses partial updates, conflicting writes, stale table views, duplicate records, and failure recovery as concrete reliability cases.
- What you can do after
- Operate shared Iceberg tables safely without external locking or coordination.
Read how Architecting an Apache Iceberg Lakehouse explains ACID →
The Coder Cafe
ACID is a set of database transaction properties—atomicity, consistency, isolation, and durability—that define reliable transaction behavior.
- How it is used
- Defines the reliability promises expected of single-node database transactions before considering distributed-data trade-offs.
- How deep it goes
- Defines atomicity and consistency with examples, while naming isolation and durability without detailing their mechanisms here.
- Examples
- Uses a bank transfer, foreign key constraints, customer balances, and a database write paired with a Kafka message.
- What you can do after
- Evaluate/understand which transaction promises a database offers and which invariants or cross-system guarantees need separate attention.
ScyllaDB in Action
ACID is a set of transaction guarantees comprising atomicity, consistency, isolation, and durability.
- How it is used
- Frames transaction guarantees for choosing between relational databases and distributed systems with weaker consistency.
- How deep it goes
- Defines all four guarantees and contrasts their trade-offs with BASE, without detailing transaction implementation internals.
- Examples
- Uses concurrent bank-account operations to demonstrate the practical importance of isolation.
- What you can do after
- Evaluate whether an application needs stronger transactional guarantees than a BASE-oriented distributed database provides.
PostgreSQL Mistakes and How to Avoid Them
ACID is the set of atomicity, consistency, isolation, and durability properties that characterize reliable database transactions.
- How it is used
- Explains why PostgreSQL transaction guarantees do not automatically cover application workflows spanning primaries and read replicas.
- How deep it goes
- Distinguishes per-node ACID safety from distributed transactions and outlines Two-Phase Commit without implementing its full protocol.
- Examples
- Uses a stale account balance, a mistaken bonus, primary alpha, and standby beta to demonstrate a cross-node consistency failure.
- What you can do after
- Diagnose/debug with it by separating database-level ACID guarantees from application-level coordination across replicated nodes.
Read how PostgreSQL Mistakes and How to Avoid Them explains ACID →
Kafka for Architects
ACID is the set of atomicity, consistency, isolation, and durability properties that define conventional transactional behavior.
- How it is used
- Frames transactional guarantees for Kafka read-process-write pipelines and exactly-once event processing.
- How deep it goes
- Defines all four properties and contrasts them with Kafka transactions, stopping short of database implementation internals.
- Examples
- Uses an OrderService writing shipment, billing, and inventory events from each order.
- What you can do after
- Apply Kafka transactions to coordinate exactly-once outputs across a read-process-write pipeline.
Digital Twins in Action
An ACID transaction is a database transaction characterized by atomicity, consistency, isolation, and durability guarantees.
- How it is used
- Uses ACID to assess reliability requirements for operational records and transactional storage.
- How deep it goes
- Defines the four-property acronym and discusses storage tradeoffs, without explaining each property or transaction internals separately.
- Examples
- Illustrates transactional storage with linked asset and work-order records and a local Delta table containing sensor readings.
- What you can do after
- Evaluate/understand ACID tradeoffs when selecting storage for operational and analytical workloads.
Also covered in
- MongoDB 8.0 in Action, Third Edition
- Think Distributed Systems
- Amazon Web Services in Action, Third Edition: An in-depth guide to AWS
- Latency
- Apache Kafka in Action
- Java Persistence with Spring Data and Hibernate epub
- First-Party Data Activation
- Just Use Postgres!
What to know first
- database transactionA database transaction is a bounded unit of database operations whose changes are treated as one logical whole, typically committed or rolled back together.
- SQLSQL is a standardized declarative language for defining, querying, and manipulating data in relational database systems.
- durabilityDurability is the ability of data, state, or a system to remain preserved, usable, or effective over time despite failures or change.
- atomicityAtomicity is the property that an operation or group of operations takes effect as an indivisible whole, without observable partial effects.
Related concepts
- atomicityhas part · Atomicity is the property that an operation or group of operations takes effect as an indivisible whole, without observable partial effects.
- isolationhas part · Isolation is the separation of components, processes, resources, or contexts to limit interaction, interference, or the propagation of effects between them.
- consistencyhas part · Consistency is the degree to which related data, behavior, or results agree with one another and conform to applicable rules or expectations.
- durabilityhas part · Durability is the ability of data, state, or a system to remain preserved, usable, or effective over time despite failures or change.
- BASEcontrasts with · BASE is a distributed-systems consistency model characterized by basic availability, soft state, and eventual consistency.
- eventual consistencycontrasts with · Eventual consistency is a distributed-data consistency model in which replicas may temporarily differ but converge to the same state if updates cease and have time to propagate.
Questions about ACID
What is ACID?
ACID is the set of database transaction properties—atomicity, consistency, isolation, and durability—that characterize reliable transactional behavior.
Which Manning books explain ACID?
Grokking Software Architecture, 100 SQL Server Mistakes and How to Avoid Them, Building Web APIs with ASP.NET Core, Microservices Patterns, Second Edition, Architecting an Apache Iceberg Lakehouse, The Coder Cafe, ScyllaDB in Action, PostgreSQL Mistakes and How to Avoid Them and 2 more.
What should I know before learning ACID?
Manning books that teach ACID usually introduce database transaction, SQL, durability and atomicity first.
What is the difference between ACID and BASE?
ACID is the set of database transaction properties—atomicity, consistency, isolation, and durability—that characterize reliable transactional behavior. BASE is a distributed-systems consistency model characterized by basic availability, soft state, and eventual consistency.
What are the parts of ACID?
ACID includes atomicity, isolation, consistency and durability.
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.









