InfoWok
// course · free · self-paced

System Design Interview

The building blocks, the trade-offs and the classic problems, taught with one repeatable framework for the 45-minute round.

by the endYou can run a 45-minute system design round: clarify requirements, estimate scale, draw the architecture, go deep on one or two components, and defend your trade-offs.

SK
Sukhveer Kaur
Software Developer & AI Engineer
8
Modules
15 +24
Lessons (+coming)
~2 h
Total read
Intermediate
Level

Before you start: You have built or maintained a backend service and know what a database and an API are.

15 lessons
Start → System Design Building Blocks: A Decisio…
  1. Module 0 — How the round works

    0 · ~0 min · optional

    Optional. The framework interviewers expect and the arithmetic you need at the whiteboard.

    you canYou know the steps of the round and can size a system on the back of an envelope.

    1. The system design interview frameworkcoming soonLesson
    2. Back-of-envelope estimation primercoming soonLesson
    3. Common system design interview mistakescoming soonOptional
  2. Module 1 — Building blocks

    7 · ~37 min

    The components every design is assembled from, and when each one earns its place.

    you canYou can pick and justify each component rather than name-drop it.

    1. System Design Building Blocks: A Decision Map, Not a Parts List (2026)Lesson · 6 min
    2. Load Balancers Explained: Health Checks Do the Real Work (2026)Lesson · 5 min
    3. Caching Strategies: Why Invalidation Is the Hard Part (2026)Lesson · 7 min
    4. CDNs and Object Storage: Store at the Origin, Serve at the Edge (2026)Lesson · 5 min
    5. API Gateway Explained: It’s Not a Load Balancer (2026)Lesson · 4 min
    6. Rate Limiting Explained: Token Bucket, Leaky Bucket, and When Each Wins (2026)Lesson · 5 min
    7. Horizontal vs Vertical Scaling: Scale Up Until You Can’t (2026)Optional · 5 min
  3. Module 2 — Data and consistency

    2 · ~10 min

    Choosing a datastore, spreading data across machines, and what you give up when you do.

    you canYou can choose a datastore, explain replication and sharding, and state the trade-off.

    1. SQL vs NoSQL: It’s About Access Patterns, Not Scale (2026)Lesson · 5 min
    2. CAP Theorem Explained: It Was Never ‘Pick Two’ (2026)Lesson · 5 min
    3. Database sharding and replication explainedcoming soonLesson
    4. Consistent hashing explainedcoming soonLesson
    5. Indexing and query performance primercoming soonOptional
  4. Module 3 — Async and messaging

    3 · ~19 min

    Decoupling services with events, queues and streams.

    you canYou can decouple services with queues and streams and explain delivery guarantees.

    1. Monolith vs Microservices: It’s About Team Size, Not Traffic (2026)Lesson · 7 min
    2. Event-Driven Architecture: Trading Control for Decoupling (2026)Lesson · 5 min
    3. Kafka vs RabbitMQ: A Log vs a Queue, Not Fast vs Slow (2026)Lesson · 7 min
    4. Message delivery guarantees and idempotencycoming soonLesson
  5. Module 4 — Classic problems

    0 · ~0 min

    Ten full designs, each walked with the same template: requirements, estimates, API, data model, diagram, deep dive, bottlenecks.

    you canYou can walk a full design from a one-line prompt using the same framework each time.

    1. Design a URL shortenercoming soonID generation, hashing, read-heavy cachingLesson
    2. Design a rate limitercoming soonToken bucket, distributed countersLesson
    3. Design a news feedcoming soonFan-out on write vs read, rankingLesson
    4. Design a chat systemcoming soonWebSockets, ordering, presenceLesson
    5. Design a notification servicecoming soonQueues, retries, dedupeLesson
    6. Design a file storage servicecoming soonChunking, sync, object storageLesson
    7. Design a web crawlercoming soonFrontier queue, politeness, dedupeLesson
    8. Design a video streaming servicecoming soonCDN, transcoding pipelineLesson
    9. Design a ride-sharing servicecoming soonGeospatial indexing, matchingLesson
    10. Design a typeahead searchcoming soonTries, caching, rankingLesson
  6. Module 5 — Reliability and operations

    0 · ~0 min

    What interviewers ask once the happy path is drawn.

    you canYou can discuss failure, observability and security when the interviewer pushes.

    1. Failure modes and resilience patternscoming soonLesson
    2. Observability for system design interviewscoming soonLesson
    3. Authentication and authorization in system designcoming soonOptional
  7. Module 6 — Modern and AI systems

    3 · ~24 min

    The AI-flavoured design questions that general interview sites cover thinly.

    you canYou can handle LLM, gateway and agent design questions.

    1. LLM System Design Interview: The Five-Layer Answer (2026)Corrected 16 OctInterview · 11 min
    2. AI Gateway Design: One Front Door for Every Model (2026)Lesson · 8 min
    3. Agent Orchestration Patterns: A 2026 GuideLesson · 5 min
    4. Design a RAG search systemcoming soonLesson
  8. Module 7 — Finish

    0 · ~0 min

    Practice under time pressure and plan the last weeks.

    you canYou have a drill routine, a review rubric and a 2–4 week schedule.

    1. Mock interview practice guidecoming soonCapstone
    2. System design interview prep plancoming soonCapstone
    3. Communication in the system design roundcoming soonOptional

Preparing for interviews specifically? The System Design Building Blocks: A Decision Map, Not a Parts List (2026) hub lists every round; each module above ends with the questions for its round.

Progress is stored only in this browser; use "Continue on another device" to carry it over. Lessons marked "coming soon" are planned and not yet published.