Skip to content
learn
  1. Learn
  2. High Level System Design
  3. The System Design Interview Framework

System Design HLD-18.03

Drawing the high-level diagram

Start with the simplest design that works, evolve it only for a stated reason, draw read and write paths separately, and label every arrow.

Beginner 8 min Last reviewed

The big idea

The high-level diagram is the centerpiece of a design discussion, and the most common way to make it worse is to make it bigger. A diagram that starts with fourteen boxes, three queues and Kafka before anyone knows why is hard to follow and impossible to defend. A strong diagram starts with the simplest thing that could work and grows one justified step at a time, so every box has a reason the listener already heard.

Good diagrams are also read, not just looked at. Every arrow says what flows along it, and the read path and the write path are traced separately, because they usually have very different requirements: reads are often far more frequent and need to be fast, while writes need to be durable.

Think of giving directions. "Take the main road, turn left at the bakery, it's the blue door" beats a full city map. Add detail only where the route needs it.

How it works

Step 1: Start with the minimum

Client, load balancer, one service, one database. Say it out loud: "This works for a few thousand users." Then check it against the requirements and the estimates.

Step 2: Evolve for stated reasons

Evolving a diagram one justified step at a time Step 1: client, load balancer, service, database. Step 2: a cache is added in front of the database because reads are 100 times more frequent than writes. Step 3: a queue and worker are added because sending notifications must not slow down the write path. Each addition is labeled with its reason. HTTPS write: INSERT read: GET, miss -> DB enqueue Client Load balancer Service Database Cache reads 100x writes Queue notifications off the write path Worker Figure 1. Each box is added with its reason. Press Next to replay how the design grows: the cache answers the read-heavy estimate, the queue keeps slow notifications off the write path.
  1. Minimum Client, load balancer, one service, one database. It works for small scale; say so.
  2. Add a cache The estimate says reads outnumber writes 100 to 1, so popular reads come from a cache in front of the database.
  3. Add a queue Sending notifications is slow and can fail; the write path enqueues a job and returns, and workers do the slow part.

Each addition answers a specific requirement or number: a cache because reads are 100 times writes, replicas because availability must be 99.99 percent, a queue because a slow side effect must not hold up the user, shards because storage passes what one machine holds ( Partitioning and sharding ). If you cannot name the reason, leave the box out.

Step 3: Make it readable

  • Trace the read and write paths separately, out loud: "a write goes here, then here; a read checks the cache first".
  • Label every arrow with what flows along it: a request, an event, a replication stream.
  • Group by tier (edge, services, data) and keep crossing lines to a minimum.
  • Name technology only where it matters. "A key-value store" is fine until the choice affects the design.

Going deeper

Diagrams as documentation

The same habits make design documents and architecture reviews better: one diagram per concern (request flow, data flow, deployment) beats one diagram of everything, and each should be readable without the author in the room.

Trade-offs

OptionWins whenLoses when
Start minimal and evolve Interviews and reviews: every component is justified and easy to follow Nothing important; it takes a little discipline
Present the full design at once Experienced audiences who already know the problem Clarity and defensibility of individual choices

Common mistakes

  • Starting with every component you know, before any requirement justifies them.
  • Unlabeled arrows that leave the listener guessing what flows where.
  • One mixed path for reads and writes, hiding the very different needs of each.
  • Naming brands ("put Kafka here") instead of explaining the need ("a durable log consumers can replay").

Check yourself

  1. What should the first version of your diagram be?

    Show answer

    B. The simplest design that meets basic needs Start minimal, then evolve with stated reasons.

  2. Why trace read and write paths separately?

    Show answer

    B. They usually have different volumes and requirements, such as speed for reads and durability for writes Separating them reveals where caching, replication and queues belong.

  3. When should a cache appear on the diagram?

    Show answer

    B. When a requirement or estimate, such as a high read ratio, justifies it Every box should answer a specific need.

  4. What should an arrow's label say?

    Show answer

    B. What flows along it, such as a request, an event or replication Labels make the diagram readable on its own.

Recap

  • Start with the simplest design that works and say what scale it handles.
  • Add each component for a stated reason tied to a requirement or estimate.
  • Trace read and write paths separately.
  • Label every arrow with what flows along it.
  • Prefer explaining needs over naming brands.

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