ACID Properties: Complete Overview
ACID properties are the four separate guarantees that make a database transaction trustworthy: Atomicity (all operations happen or none do), Consistency (the result obeys every defined rule), Isolation (concurrent transactions do not interfere with each other) and Durability (committed changes survive crashes). Each guards against a different way a transaction could go wrong.
ACID is a single acronym, but it names four genuinely separate guarantees, and understanding how they differ, and where each one actually matters, is more useful than memorizing the four words. This article walks through all four using one running example so the distinctions are concrete rather than abstract.
The running example
A ride-hailing app processes a completed ride: it needs to charge the rider's card, credit the driver's balance, and mark the ride as completed, all as one transaction.
BEGIN;
UPDATE riders SET balance = balance - 15.00 WHERE rider_id = 501;
UPDATE drivers SET balance = balance + 12.00 WHERE driver_id = 88;
UPDATE rides SET status = 'completed' WHERE ride_id = 9001;
COMMIT;
Atomicity: all three writes, or none of them
If the server crashes after the rider's charge but before the driver's credit, atomicity guarantees the entire transaction rolls back: the rider is never charged for a ride the driver never got credited for. There's no possible outcome where only one or two of the three writes took effect.
Consistency: the result must still obey every rule
Suppose the riders table has a CHECK (balance >= -50) constraint (a small overdraft allowance, but no more). If this rider's balance would go below that, the whole transaction is rejected and rolled back, consistency won't let a rule-violating state ever get committed, no matter what the application intended.
Isolation: other transactions can't see this mid-flight
While this transaction is running, another process checking the rider's balance (say, to decide whether to let them book another ride) shouldn't see a state where the rider has already been charged but the ride isn't marked completed yet, since that's a state that only exists transiently and was never meant to be observed. Isolation is what prevents that half-finished view from leaking out to other transactions running at the same time.
Durability: once it's done, it's done
The instant this transaction commits, all three changes must survive even an immediate crash. If the server loses power one second after COMMIT returns success, the rider's charge, the driver's credit, and the ride's completed status must all still be there when the system comes back, none of it can quietly vanish.
Why all four are needed together
Each property covers a genuinely different failure mode. Atomicity alone wouldn't stop a transaction from committing an invalid result (that's consistency's job). Consistency alone wouldn't stop two concurrent transactions from interfering with each other (that's isolation's job). None of the first three would matter if a committed result could just disappear after a crash (that's durability's job). A database missing even one of these four guarantees isn't safely usable for data where correctness actually matters.
Where this matters in real systems
Every mainstream relational database (PostgreSQL, MySQL with InnoDB, SQL Server, Oracle) is built around all four ACID guarantees as a foundational design goal, not an optional feature. This is also exactly why some NoSQL databases market themselves as "eventually consistent" instead, they've deliberately relaxed one or more of these guarantees (usually isolation or immediate consistency) in exchange for higher availability or throughput, a real tradeoff rather than a shortcut.
What interviewers actually ask about ACID overall
- "Name and briefly explain all four ACID properties." Atomicity (all-or-nothing), Consistency (valid state to valid state), Isolation (concurrent transactions don't interfere), Durability (committed changes survive crashes).
- "Which ACID property would fail if two people booked the last item in stock at the same time and both succeeded?" Isolation, weak isolation can allow both transactions to read the same "1 in stock" and both commit a purchase.
- "Give an example of one transaction that would test all four properties at once." Any multi-step financial or state-changing transaction, like the ride-hailing example above, naturally touches all four.
- "Why do some databases intentionally relax ACID guarantees?" To gain higher availability or throughput in distributed systems, accepting a real tradeoff (like eventual rather than immediate consistency) rather than an oversight.
Key takeaways
- Atomicity guarantees all-or-nothing execution of a transaction's operations.
- Consistency guarantees the result always satisfies the database's defined rules and constraints.
- Isolation guarantees concurrent transactions don't see each other's incomplete, in-progress work.
- Durability guarantees a committed transaction's changes survive crashes and power loss permanently.
- All four guard against different failure modes, and a database needs all of them to be genuinely trustworthy for critical data.
More in ACID Properties
Browse all DBMS topics
Log in to save which topics you've read across every subject.
Frequently asked questions
Name and briefly explain all four ACID properties.
Atomicity (all-or-nothing), Consistency (valid state to valid state), Isolation (concurrent transactions don't interfere), Durability (committed changes survive crashes).
Which ACID property would fail if two people booked the last item in stock at the same time and both succeeded?
Isolation, weak isolation can allow both transactions to read the same "1 in stock" and both commit a purchase.
Give an example of one transaction that would test all four properties at once.
Any multi-step financial or state-changing transaction, like the ride-hailing example above, naturally touches all four.
Why do some databases intentionally relax ACID guarantees?
To gain higher availability or throughput in distributed systems, accepting a real tradeoff (like eventual rather than immediate consistency) rather than an oversight.