Lesson 1 of 15 Foundations

How to Approach a System Design Problem

A repeatable 5-step framework for system design interviews and real projects: requirements, estimates, API, high-level design, then deep dives.

30-40 min beginner 0/15 lessons done
Course contents Lesson 1 of 15 · 0 done
On this page (8 sections)
  1. What you will learn
  2. What system design is
  3. The five-step framework
  4. Common mistakes
  5. How this course is organised
  6. Key takeaways
  7. Exercises
  8. Quiz

What you will learn

  • What “high-level design” (HLD) means and how it differs from low-level design.
  • A five-step framework you can apply to any design question.
  • How to turn a vague prompt into functional and non-functional requirements.
  • The most common ways candidates (and teams) go wrong.

What system design is

System design is deciding which components a product needs (servers, databases, caches, queues, CDNs), how they talk, and how the whole thing behaves as traffic grows and parts fail. It’s called high-level design because you work with boxes and arrows, not classes and methods. Class-level design is the subject of our Low-Level Design course.

There’s rarely one right answer. A good design is one whose trade-offs are explicit and fit the requirements: cheaper vs faster, simpler vs more available, fresher data vs lower latency.

The five-step framework

1. Requirements      what must it do, and how well?          (5-8 min)
2. Estimates         how big is it?                            (3-5 min)
3. API + data model  what goes in and out, what is stored?    (5 min)
4. High-level design boxes and arrows for the main flows      (10-15 min)
5. Deep dives        bottlenecks, failures, trade-offs         (10-15 min)

The times are for a 45-minute interview; in a real design document the same steps take days. The order matters more than the timing.

Step 1: Requirements

Split them in two.

Functional requirements are features: “users can shorten a URL”, “a short URL redirects to the original”, “links can expire”. Pick the 2–4 that matter most and say what you’re leaving out.

Non-functional requirements are qualities, ideally with numbers:

QualityQuestion to askExample answer
ScaleHow many users / requests?100M new links a day
LatencyHow fast must it feel?Redirect p99 under 50 ms
AvailabilityHow much downtime is OK?99.99% for redirects
ConsistencyCan readers see stale data?A new link may take a second to work everywhere
DurabilityCan we ever lose data?Never lose a created link

Non-functional requirements drive the architecture. “Read-heavy with strict latency” points to caching; “must never lose a payment” points to strong consistency and replication with synchronous acknowledgement.

Step 2: Estimates

Rough numbers decide whether one database is enough or you need fifty shards. Lesson 2 teaches the arithmetic.

Step 3: API and data model

Write the few endpoints the core flows need and the main entities:

POST /links          {long_url, expires_at?}  -> {code}
GET  /{code}         -> 301/302 redirect

links(code PK, long_url, owner_id, created_at, expires_at)

This keeps the rest of the discussion concrete.

Step 4: High-level design

Draw the request path for each core flow. Start simple, then add components only when a requirement demands them:

client -> load balancer -> app servers -> database
                              |
                              +-> cache (because reads are 100x writes)

Step 5: Deep dives

Pick the hardest parts and go deep: the hot key, the database that won’t fit on one machine, what happens when a data centre fails. Name the bottleneck, offer two options, choose one and say why.

Common mistakes

  • Designing before asking. Five minutes of questions saves twenty of redesign.
  • Buzzword architecture. Adding Kafka, Kubernetes and five microservices to a system with 100 users. Every component must earn its place.
  • No numbers. “It needs to scale” means nothing; “350k reads per second at peak” means a cache.
  • Ignoring failure. Every box can die. What happens then?
  • Silence about trade-offs. Saying “I chose X over Y because…” is the core skill being tested.

How this course is organised

Lessons 2–9 build the toolbox: estimation, scaling, caching, databases, sharding, consistency, queues and APIs. Lessons 10–14 apply it to classic case studies: a URL shortener, a rate limiter, a chat system, a news feed and a notification system. Lesson 15 covers reliability and a printable checklist. For practice prompts, pair this course with the HLD practice sheet.

Key takeaways

  • High-level design is about components, data flow and trade-offs, not code.
  • Follow the order: requirements, estimates, API/data model, high-level design, deep dives.
  • Non-functional requirements (scale, latency, availability, consistency) drive the architecture.
  • Add components only when a requirement justifies them, and always state the trade-off.

Exercises

  1. For “design Instagram”, write three functional and four non-functional requirements with numbers you’d propose.
  2. Take a system you use at work or university and draw its high-level diagram in under ten boxes.
  3. Pick any prompt from the HLD sheet and spend 10 minutes only on step 1. List the questions you’d ask the interviewer.

Quiz

  1. What is the difference between a functional and a non-functional requirement?
  2. Why should estimates come before drawing the architecture?
  3. Name two signs of “buzzword architecture”.
Show answers
  1. Functional requirements describe what the system does (features); non-functional ones describe how well it must do it (scale, latency, availability, consistency, durability).
  2. The numbers decide which components you need: whether one database suffices, whether you need a cache, sharding or a CDN.
  3. Components added without a requirement that needs them, and complexity (many services, queues, clusters) far beyond the stated scale.

Finished this lesson?

Mark it complete to track your progress (saved in this browser).