ACID properties for system design interviews, explained
The moment a design touches money, orders, or anything that must not be half-done, someone says "it needs to be a transaction" — and the interviewer's next question is what that actually guarantees. ACID is the four-letter answer: atomicity, consistency, isolation, durability — the promises a database makes so that a transaction behaves like a single, all-or-nothing, uninterrupted, permanent operation even under crashes and concurrency. It is one of the most common system design interview concepts because the headline is easy to recite and the depth lives underneath: which property a given failure violates, what the isolation levels really trade, and when a distributed system deliberately gives ACID up for speed and availability.
The reason it comes up everywhere is that ACID is the vocabulary for talking about correctness under two hostile conditions — things failing mid-write, and many things writing at once. A transfer that debits one account but crashes before crediting the other, two users booking the last seat simultaneously, a committed payment vanishing in a power cut: each is a different ACID property failing, and an interviewer uses them to tell whether you can name the guarantee that is actually at risk. This guide walks what a strong candidate says out loud: the four properties and what each protects, the isolation levels and the anomalies they prevent, ACID vs BASE and why distributed stores relax the rules, and how databases implement the guarantees underneath.
Why ACID comes up in system design interviews
ACID rarely gets its own prompt. It surfaces inside a design — a payment system, an order-management flow, a ticket booking — at the moment the interviewer asks what happens when two writes collide or a node dies mid-operation. You say "it's a transaction, so it's ACID," and the follow-up lands on the weakest word in that sentence: which property, exactly, is keeping you correct, and what does enforcing it cost? ACID is a favourite probe because "use a transaction" is the easy half, and the hard half is isolation — the single most misunderstood letter — and the decision to relax the whole acronym at scale.
The interviewer rarely lets "we'll wrap it in a transaction" stand on its own. "Two people try to book the last seat at the same instant. Both transactions read 'one seat left,' both book it. Which ACID property did that violate, and what isolation level would have stopped it — and what does that level cost you?" That question — naming the exact guarantee and its price — is the one a memorised "ACID means atomicity, consistency, isolation, durability" answer can never survive.
The rounds on Zynter are modelled on how the loop runs, not scraped from any candidate's recall. What matters for prep is the shape: you name a property, and the next sentence attacks the concurrency case or the crash case it is supposed to cover.
What the interviewer is really testing
An ACID answer is read on the same four dimensions as any design decision. Problem solving — did you identify which property a failure threatens, or recite all four? Communication — can you say in one sentence what isolation buys and what it costs? Technical execution — do you know the read anomalies and the isolation levels that prevent each, and how durability survives a crash? Time management — did you spend your words on isolation and the ACID-vs-BASE trade, not on defining "atomic" three ways? Reading this guide teaches the properties; it does not teach you to defend an isolation choice while someone describes a race.
The four properties: atomicity, consistency, isolation, durability
Start with the guarantees themselves, each tied to the failure it defends against:
- Atomicity — a transaction is all-or-nothing. Every operation inside it either all commit together or all roll back; there is no half-done state. A transfer that debits account A must not leave the money gone if crediting account B fails — the whole thing undoes. Atomicity defends against partial failure.
- Consistency — a transaction moves the database from one valid state to another, never leaving it violating its rules (constraints, foreign keys, invariants like "balance ≥ 0"). If a transaction would break an invariant, it is rejected. (This is the "C" that is really the application's and the schema's job, not a concurrency guarantee — worth noting, as it is the most hand-waved letter.)
- Isolation — concurrent transactions do not step on each other; the result is as if they ran one at a time, even when they actually overlap. Isolation defends against concurrency anomalies, and it is the property with a dial — you choose how much isolation, trading strictness for throughput.
- Durability — once a transaction commits, its effect survives crashes, power loss and restarts. The change is on non-volatile storage (and its log) before the commit is acknowledged, so the database recovers to its last committed state. Durability defends against crash failure.
The sentence that scores: atomicity is all-or-nothing, consistency keeps every state valid, isolation makes concurrent transactions behave as if serial, and durability makes a commit permanent — and in practice the two that generate every hard interview question are isolation (the concurrency dial) and durability (the crash guarantee). Naming which property a given failure violates is the whole skill.
Isolation levels and the anomalies they prevent
This is where the interview gets its depth, because isolation is a dial, not a switch. Weaker isolation is faster and more concurrent but allows read anomalies; stronger isolation prevents them but costs throughput through locking or aborts. Name the three anomalies and the levels that remove each:
- Dirty read — a transaction reads another transaction's uncommitted change, which may then roll back, so it read a value that never really existed.
- Non-repeatable read — a transaction reads the same row twice and gets different values, because another transaction committed an update in between.
- Phantom read — a transaction runs the same query twice and the set of rows changes, because another transaction inserted or deleted rows matching the condition.
The standard isolation levels, from weakest to strongest, each closing off one more anomaly:
| Isolation level | Dirty read | Non-repeatable read | Phantom read |
|---|---|---|---|
| Read uncommitted | possible | possible | possible |
| Read committed | prevented | possible | possible |
| Repeatable read | prevented | prevented | possible |
| Serializable | prevented | prevented | prevented |
The sentence that scores: weaker isolation gives more concurrency but lets anomalies through; serializable is the strongest and behaves as if transactions ran one at a time, but it costs the most in locking or aborts — so I'd pick the lowest level that is still correct for this operation, and reach for serializable (or an explicit lock) only where a race would corrupt data, like booking the last seat. Knowing that most databases default to read committed — and that this still allows non-repeatable and phantom reads — is the detail that signals you have debugged a real concurrency bug.
System Design
HLD · Core concept
Name the anomaly and the isolation level out loud
ACID vs BASE: when you relax the guarantees
The most important follow-up at scale is why you would give up ACID — because distributed systems often cannot have it cheaply. The alternative philosophy is BASE: Basically Available, Soft state, Eventual consistency. Where ACID insists every read sees the latest committed write, BASE accepts that replicas converge eventually, trading immediate consistency for availability and scale.
The reason is the CAP trade-off: once data is replicated across nodes and the network can partition, you cannot have strong consistency and full availability at the same time. A single-node relational database gives you ACID easily; a globally-distributed store serving millions of writes often chooses availability and settles for eventual consistency, because waiting for every replica to agree on every write would be too slow. So many NoSQL systems are BASE by default, while offering stronger guarantees as an opt-in.
The sentence that scores: ACID is the right default for data where a wrong answer is unacceptable — money, inventory, orders — even if it limits scale; BASE trades immediate consistency for availability and horizontal scale, which is fine for data where a brief disagreement is harmless, like a view count, a feed, or a social graph. Framing it as pick the weakest consistency the use case tolerates — rather than "SQL good, NoSQL bad" — is what reads as judgment. Note too that "consistency" means something different in ACID (valid state per the schema) than in CAP (every read sees the latest write); conflating the two is a common slip.
System Design
HLD · Core concept
Defend ACID vs BASE for a given data type out loud
How databases actually implement ACID
"The database handles it" is true, but knowing how separates a recited answer from an understood one. Each property is enforced by a concrete mechanism:
- Durability and atomicity — the write-ahead log (WAL). Before a change is applied, the database writes it to an append-only log on disk and flushes that log before acknowledging the commit. If the system crashes, recovery replays the log to re-apply committed transactions (durability) and rolls back incomplete ones (atomicity). The log is the single source of truth that survives the crash.
- Isolation — locking or MVCC. Weaker isolation is cheap; stronger isolation is enforced either with locks (readers and writers block each other to prevent anomalies) or with multi-version concurrency control (MVCC), where each transaction reads a consistent snapshot of the data as of its start, so readers never block writers. MVCC is why modern databases can offer repeatable-read-style isolation without grinding to a halt under read load.
- Consistency — constraints and the above. The valid-state guarantee is the schema's constraints plus whatever atomicity and isolation enforce; it is the one property the application and schema own as much as the engine.
The point to state plainly: durability and atomicity ride on the write-ahead log, isolation rides on locks or MVCC, and consistency is the constraints on top — so when an interviewer asks "how does a commit survive a crash?" the answer is "the WAL was flushed first," not "it's durable because ACID."
How to talk about ACID in an interview
The probes from every section rhyme. Master these five and you can defend a transactional decision in any design, not just this checklist.
- "What does ACID actually guarantee?" → Atomicity (all-or-nothing), consistency (always a valid state), isolation (concurrent transactions behave as if serial), durability (a commit survives a crash) — and the two that matter in practice are isolation and durability. (problem solving)
- "Two transactions race on the last seat — which property, which level?" → Isolation; read committed would still let both book it, so you need serializable or an explicit lock on that row to serialise them. (technical execution)
- "What read anomalies exist and which level stops each?" → Dirty read (stopped at read committed), non-repeatable read (stopped at repeatable read), phantom read (stopped at serializable); weaker levels trade correctness for concurrency. (communication)
- "When would you give up ACID?" → For data where a brief disagreement is harmless and scale matters — feeds, counts, social graphs — you accept BASE and eventual consistency per the CAP trade-off; you keep ACID for money and orders. (problem solving)
- "How does a committed write survive a power cut?" → The write-ahead log is flushed to disk before the commit is acknowledged, and recovery replays it; atomicity rolls back incomplete transactions from the same log. (technical execution)
Each maps to a debrief dimension. Reading them teaches the answers; it does not teach you to deliver them while someone describes the race — that only comes from saying them out loud.
How to prepare: a short plan
You do not need a new topic for every design. You need the ACID vocabulary automatic, so when a design touches money or inventory you reach for the right guarantee and level without thinking.
- Day 1: Learn the four properties tied to the failure each prevents (partial, invalid, concurrent, crash), until you can say which one a given bug violates.
- Day 2: Drill isolation — the three read anomalies and the four levels that close them off, plus that read committed is the common default. This is where the follow-ups live.
- Day 3: Place ACID inside a real design (a payment, a booking): choose transactions where correctness is non-negotiable, pick the lowest safe isolation level, and say where you'd relax to BASE. Then do it out loud, timed, with someone describing a concurrency race.
This explainer feeds the broader Top 25 system design interview questions — transactional correctness is a decision inside payments, bookings and inventory designs, so getting ACID automatic pays off across the whole list.
Frequently asked questions
What are the ACID properties in a database?
ACID is the set of four guarantees a database makes about a transaction. Atomicity means the transaction is all-or-nothing: every operation inside it either commits together or rolls back entirely, with no half-done state. Consistency means a transaction only ever moves the database from one valid state to another, never leaving it violating its constraints or invariants. Isolation means concurrent transactions do not interfere — the outcome is as if they had run one at a time. Durability means that once a transaction commits, its effect survives crashes, power loss and restarts because it was persisted (and logged) before the commit was acknowledged. Together they let a transaction behave like a single, reliable, permanent unit even under failures and concurrency.
What are isolation levels and the anomalies they prevent?
Isolation levels control how much concurrent transactions are allowed to see of each other, trading strictness for throughput. From weakest to strongest: read uncommitted allows dirty reads (reading another transaction's uncommitted, possibly-rolled-back data); read committed prevents dirty reads but still allows non-repeatable reads (a row's value changing between two reads) and phantom reads (the set of rows matching a query changing); repeatable read also prevents non-repeatable reads but can still allow phantoms; and serializable prevents all three, behaving as if transactions ran one at a time, at the highest cost in locking or aborts. Most databases default to read committed, so a strong answer picks the lowest level that is still correct for the operation and escalates to serializable (or an explicit lock) only where a race would corrupt data.
What is the difference between ACID and BASE?
ACID and BASE are opposite philosophies for consistency. ACID (atomicity, consistency, isolation, durability) insists that every read sees the latest committed write and that transactions are strongly consistent — ideal for money, orders and inventory where a wrong answer is unacceptable, but harder to scale across many nodes. BASE (basically available, soft state, eventual consistency) relaxes immediate consistency: replicas converge eventually, trading up-to-the-moment correctness for availability and horizontal scale, which is fine for data where a brief disagreement is harmless, such as feeds, view counts or social graphs. The choice follows the CAP trade-off — once data is replicated and the network can partition, you cannot have both strong consistency and full availability — so you pick the weakest consistency the use case can tolerate.
How do databases implement durability?
Through a write-ahead log. Before a transaction's changes are applied to the main data files, the database records them in an append-only log on disk and flushes that log to non-volatile storage before it acknowledges the commit to the client. That ordering is what makes durability real: if the system crashes immediately after the commit, recovery reads the log and replays the committed changes so nothing is lost, and it rolls back any transactions that were incomplete at the crash, which is how atomicity is also enforced. The same log underpins replication in many systems. So when a committed write survives a power cut, it is because the write-ahead log was durably written first, not because the row was magically saved.
How do I practise a system design interview out loud?
Reading about ACID is not the same as defending an isolation choice while an interviewer describes a race. On Zynter, the HLD track runs live voice rounds modelled on how real system design loops run — you talk through a design on a shared canvas, and a voice interviewer follows up one question at a time ("which property did that race violate?", "what isolation level stops it, and what does it cost?", "when would you give up ACID?"), then gives you a debrief on problem solving, communication, technical execution and time management. The score is a practice signal, not a hiring decision.
Practise it on Zynter
You can recite the four letters. The round is won on naming the guarantee a race actually breaks.
Pick an HLD system design round, choose where your design needs a transaction, and defend it out loud to a voice interviewer that keeps asking "which property does this race violate?" and "what isolation level stops it, and what does it cost?" — then read the debrief. Zynter.ai is on-demand mock interviews modelled on real company loops, with 150+ rounds across 20 companies including the HLD system design track (Sep 2026).
Practise an HLD system design round →
Browse all interview tracks




Top comments (0)