Leet School
SHORT COURSE

System Design

Design for load, failure and change by writing a real design document and testing the riskiest parts of the system with code that runs.

  • About 6 weeks
  • Intermediate
  • About 10 hours a week
  • Self-paced, text-based
  • Code checks and AI feedback
$250One price, any pace

One payment. Every lesson unlocks at once.

Start this course

Start today. 14-day full refund.

Pace
Yours, about 6 weeks
Level
Intermediate
You build
One deep project
Lessons
18 text lessons, about 8 hours of reading
Feedback
Code checks every project, then AI

{about this course}

What it is

Most system design material is about systems you will never run. This course uses the kind you already run: a booking and checkout service with one database, a payment provider and a messaging provider. The questions are the ones that matter on a busy day. What happens when bookings jump tenfold in an hour? When the payment provider takes ten seconds to answer? When you must change a table that is in use?

Over an orientation and three modules you design one system for one client, an intercity coach company, and build a prototype of its riskiest parts. You estimate load with arithmetic you can show, choose indexes, transactions, queues, limits, caches and timeouts for stated reasons, then load the prototype and inject failures to see whether the design holds. Each module adds sections to your design document and ends in a milestone that is checked automatically and read by AI.

Every lesson is text with TypeScript and SQL that runs. Each one is built around a small experiment whose numbers are the evidence for its idea: a queue that grows, a cache before and after, a read that is stale because a copy lags. You also practise the writing the job needs: a design document, decision records, a runbook and a review log.

{outcomes}

By the end you can

  • Turn a vague request into written requirements, a capacity estimate and a latency budget, with arithmetic you can show
  • Choose indexes, transaction boundaries, replicas and caches for stated reasons, and name what each one can break
  • Protect a service under load with queues, bounded concurrency, rate limits and more instances, and find where it stops scaling
  • Design for failing dependencies with timeouts, retries with jitter, idempotency keys and circuit breakers
  • Change a running system safely with expand and contract migrations, feature flags, compatible API changes and a rollback plan
  • Load test a prototype, inject faults into it and report the results honestly
  • Write a design document and decision records another engineer can review, and defend them with evidence

{projects}

The one project you build

  1. Project 1: A design document and a tested prototype

    A design for an intercity coach company's booking and ticket system, covering requirements, numbers, data, load, failure and change, built in three milestones. It is backed by a prototype of the riskiest parts, which you load test and then break on purpose, with decision records, a runbook and a review log.

    • TypeScript
    • Node.js
    • PostgreSQL
    • Express
    • pg-boss
    • Mermaid
    • Markdown

{syllabus}

Everything you will read and build

4 modules · 18 lessons · 4 projects

How the school and this course work, the six-step method and the debugging loop, the tools to check on your computer, and the accounts you will use to learn in public.

  • How Leet School works

    You can describe the loop of a lesson, a module and a milestone, say what this course builds, and plan about 18 hours a module around your job.

    15 min
  • The method and asking for help

    You can use the six-step method on a design question with no code, follow the debugging loop, and write a question that gets a useful answer.

    20 min
  • Your tools, your accounts and learning in public

    You can check that Node.js and PostgreSQL are ready, set up the accounts the course uses, and write a learning log that never gives away what it should not.

    20 min
  • Weekly check and weekly article

    A few questions answered in your own words, marked at once, and one article about the week.

  • Your learning home and your workbench

    You publish a GitHub profile page that says what you are learning, create the altiplano-coaches repository that every milestone builds on, and write your first public post.

    Set-up project

{is this for you}

Who System Design is for

It suits you if

  • Developers who run a production service and want to reason about its limits before it reaches them
  • Engineers starting to lead projects, who now have to write design documents and review other people's
  • Freelancers and agency developers whose client systems are outgrowing one server and one database
  • Developers who want design practice on systems of ordinary size, not memorised diagrams of very large ones

Pick something else if

  • People who have not yet built and deployed a web application with a database. Build one first
  • Anyone who wants only timed interview drills on designing very large consumer systems
  • Teams that need training in administering one tool such as Kubernetes, Kafka or Redis. The course teaches the decisions, not the tool

{before you start}

What you need

  • You have built or maintained a web application with an HTTP API and a relational database
  • You can read and write TypeScript or JavaScript, including async code, and basic SQL
  • You are comfortable with Git, npm and the command line
  • Node.js 26 and PostgreSQL 17 or newer on your own computer, both free. Orientation shows how to check them

{tools}

Tools you will use

  • TypeScript
  • Node.js
  • PostgreSQL
  • node-postgres
  • Express
  • pg-boss
  • k6
  • Mermaid
  • Git

{faq}

Questions about this course

Something else? Ask us directly.

No. Every example is a system of ordinary size, with one or two servers, one PostgreSQL database, a payment provider and a messaging provider. That is the size of system most developers run, and the size where these decisions are made by one person or a small team.

Start System Design today.

$250. No application. Change your mind within 14 days for a full refund.