Skip to content
System design course
Ch.3 · Trade-offs that define a design·concept ·6 min read

Why trade-offs matter in interviews

Every architectural choice buys one quality by spending another. Naming the exchange — not just the pick — is what separates senior signal from recitation.


There is no free lunch

A system design has no “correct” architecture, only one that’s right for the stated requirements. That’s because every meaningful decision is an exchange: a cache buys read latency and spends consistency; replication buys durability and spends write latency; microservices buy team autonomy and spend operational complexity. The interviewer is testing whether you see the exchange and can choose deliberately.

What “discussing trade-offs” actually signals

When you articulate a trade-off, you demonstrate four things at once:

  • Maturity — you know nothing is free, so you’ve clearly shipped real systems.
  • Critical thinking — you can hold two options and reason about which fits.
  • Requirements-driven design — your choice traces to a stated need, not a fashion.
  • Communication — you can make the reasoning legible to a teammate.

A candidate who says “I’ll use NoSQL because it scales” has named a fact. One who says “writes dominate and I can model this as known access patterns, so I’ll take a wide-column store and give up ad-hoc joins and multi-row transactions” has designed.

The shape of a good trade-off statement

Three parts, in order:

  1. The choice — “I’ll serve the feed from read replicas.”
  2. What it buys — “which scales reads and lowers latency in-region.”
  3. What it costs, and why that’s acceptable here — “at the price of eventual consistency, which is fine for a feed — a few seconds of staleness is invisible.”

That third clause is the one juniors drop. It’s the most important.

The recurring axes

Most trade-offs in this chapter are instances of a few deep tensions you’ll keep meeting:

  • Consistency vs latency/availability (CAP/PACELC made concrete).
  • Latency vs throughput — optimizing per-request speed vs total volume.
  • Read performance vs write performance — indexes, caches, and denormalization help one and tax the other.
  • Simplicity vs scalability — more capable usually means more moving parts.
  • Cost vs everything — more replicas, caches, and regions all cost money.

How to wield it

Don’t list trade-offs academically. Attach one to each decision as you make it, and revisit them when requirements change (“if this became write-heavy, I’d revisit the index strategy”). The rest of this chapter arms you with the specific exchanges; this lesson is the habit: every pick comes with a price you say out loud.