Skip to content
learn
  1. Learn
  2. High Level System Design
  3. Core Concepts and Back-of-the-Envelope Math

System Design HLD-02.07

The core trade-offs map

The trade-offs every design review returns to: consistency, availability, latency, cost, reads vs writes, simplicity, and how to argue them.

Intermediate 10 min Last reviewed

The big idea

There is no best architecture, only architectures that fit a set of requirements. Every decision buys something and pays for it somewhere else: a cache buys speed and pays in staleness, a second region buys resilience and pays in cost and consistency, splitting into microservices buys team independence and pays in operational complexity. The skill that separates senior designers is not knowing more components. It is naming the trade-off out loud and tying it to a requirement.

This lesson is a map of the trade-offs that come up again and again. You will see each of them in depth later. For now, the goal is to recognize them, because once you do, most design debates become short: "we are choosing latency over consistency here, because a stale like count is harmless".

How it works

Step 1: The recurring axes

  • Consistency vs availability. When the network splits replicas apart, a system must either refuse some requests to stay consistent or keep answering and risk returning old or conflicting data. This is the CAP theorem, in CAP theorem, properly explained .
  • Latency vs consistency. Even without failures, making every replica agree before answering takes extra round trips. Reading from a nearby replica is fast but may be slightly behind. PACELC, in PACELC and consistency models , names this.
  • Cost vs performance and reliability. More replicas, more regions, more cache memory: each improves something and adds to the bill.
  • Read vs write optimization. Indexes, caches and precomputed or denormalized data make reads fast and writes slower and more complex. Append-only logs make writes fast and reads harder.
  • Simplicity vs flexibility. A monolith is simple to build, test and deploy; microservices let many teams move independently at the price of networks, versioning and distributed debugging.

Step 2: Different products sit in different places

Here are three designs scored on five axes. Further out means better on that axis:

Three designs compared across five trade-off axes A radar chart with axes consistency, availability, low latency, low cost and simplicity. The bank ledger scores high on consistency and moderate elsewhere. The social feed scores high on availability and latency but low on consistency and simplicity. The startup MVP scores high on cost, simplicity and consistency but low on availability. Consistency Availability Low latency Low cost Simplicity Bank ledger Social feed Startup MVP Further out = better on that axis Figure 1. Illustrative scores, not measurements. Bank ledger: one primary database with synchronous replicas. Social feed: caches, async replicas, many regions. Startup MVP: one server, one database. No design covers the whole chart: the bank gives up some latency for consistency, the feed gives up consistency and simplicity for speed and availability, and the MVP gives up availability for cost and simplicity.

None of the shapes is wrong. A bank that shows a slightly stale balance is broken; a social feed that shows a like count two seconds late is fine. An MVP that goes down for an hour loses little; a feed with a billion users that goes down for an hour makes the news.

Step 3: How to argue a trade-off

In a design review or interview, a good trade-off statement has four parts:

  1. The decision: "Serve timelines from a cache that is updated asynchronously."
  2. What we gain: "Reads stay under 50 ms at 200,000 requests per second."
  3. What we give up: "A new post can take a few seconds to appear for followers."
  4. Why that is acceptable: "Users do not notice a few seconds' delay in a feed, and the requirement is read latency."

And, when you can, how you would know if it stops being acceptable: "If complaints about missing posts rise, or the delay exceeds 10 seconds at p99, we revisit."

Try it

For each product requirement, which side of the trade-off should win?

Show answers
  • Transferring money between bank accounts: Favor consistency. Showing or acting on the wrong balance can lose money. Refusing a request briefly is better.
  • Showing the number of likes on a post: Favor availability and latency. A count a few seconds old harms nobody; a slow or failing page does.
  • Selling the last seat on a flight: Favor consistency. Two people must not both get the last seat, so the booking needs one agreed answer.
  • A product recommendations carousel: Favor availability and latency. Slightly stale recommendations are fine; a missing page is not.
  • Changing a user's password: Favor consistency. The old password must stop working everywhere promptly.
  • A news site's article view counter: Favor availability and latency. Approximate, eventually correct counts are fine.

Going deeper

Trade-offs change with scale and time

The right point on each axis moves. A startup rightly favors simplicity and low cost; the same product at a billion users must buy availability and latency. A good design document records not just the choice but the conditions under which it should be revisited, so the next team knows what assumption it rests on.

Look for the hidden third option

Many trade-offs are less binary than they look. You can split a system so the parts that need strong consistency (payments) are small and strict, while everything else (feeds, search, analytics) is fast and eventually consistent. Much of good architecture is drawing those boundaries well.

Trade-offs

OptionWins whenLoses when
Favor consistency Money, inventory, identity and permissions: wrong answers are costly Latency and availability during network problems
Favor availability and latency Feeds, counters, recommendations, search: stale is harmless, slow is not Data where conflicting or outdated answers cause real damage
Favor simplicity and low cost Early products and internal tools: ship fast, change easily Very high scale or strict uptime needs, which simplicity eventually cannot meet

Common mistakes

  • Presenting a design as if it had no downsides. Reviewers then find the downsides for you.
  • Choosing the most robust option on every axis. The result is slow, expensive and complex.
  • Treating the whole system as one choice. Different data in the same product often deserves different trade-offs.
  • Stating trade-offs without tying them to requirements. "Eventual consistency is faster" is a fact, not a justification.

Check yourself

  1. A cache in front of the database mainly trades what for what?

    Show answer

    A. Consistency for latency Reads get faster, but the cache may serve data that is slightly out of date.

  2. Which feature most needs strong consistency?

    Show answer

    B. Inventory for the last item in stock Two customers must not both buy the last item, so everyone must see one agreed stock level.

  3. What makes a trade-off statement convincing in a design review?

    Show answer

    B. Stating the gain, the cost and why the cost is acceptable for the requirements Decision, gain, cost, and why it fits the requirements, ideally with a condition to revisit.

  4. Why might one product use both strong and eventual consistency?

    Show answer

    B. Different data has different needs, so each part gets the trade-off that fits Payments can be strict while feeds and analytics are fast and eventually consistent.

Recap

  • Every design decision gains on some axes and pays on others.
  • The recurring axes: consistency, availability, latency, cost, read vs write speed, simplicity.
  • Different products, and different data in one product, belong at different points.
  • State a trade-off as decision, gain, cost and why the cost is acceptable.
  • Record when to revisit: the right trade-off changes with scale.

Get new lessons by email

Get new posts on backend and AI internals. No spam, unsubscribe anytime.

Your email is only used to send new posts. Privacy

Next up