liveBook · Manning

ACID

ACID is the set of database transaction properties—atomicity, consistency, isolation, and durability—that characterize reliable transactional behavior.

How 10 Manning books explain it

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.

Read how Grokking Software Architecture explains ACID →

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.

Read how The Coder Cafe explains ACID →

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.

Read how ScyllaDB in Action explains ACID →

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.

Read how Kafka for Architects explains ACID →

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.

Read how Digital Twins in Action explains ACID →

Also covered in

What to know first

Related concepts

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.