A free system design course teaches how large software systems work through simulations you can run yourself, not just static diagrams. It has 44 finished lessons and 117 live simulations, and each lesson explains one idea in plain words.
Every simulation behaves the same way each time. You can start one, stop it, drag back through the timeline and tweak the settings to watch what fails. The material is split into 8 parts and takes about seven hours to read.
What the course covers
It opens by following a request from the browser to the database and timing each hop. Later lessons put numbers on latency, explain how DNS resolves a name, and count TCP and TLS setup in round trips. A tour of HTTP/1.1, HTTP/2 and HTTP/3 follows. The part closes with rough capacity math that converts a user count into traffic, storage and simultaneous requests.
The foundations part has 6 lessons and runs 53 minutes. The author says the notes began as personal study material and welcomes error reports and contributions through a public repository.
Scaling the web tier and caching
The second part has 6 lessons: bigger machines versus more machines, load balancing, stateless services, reverse proxies, API gateways and CDNs. One of them argues that an app server shouldn’t hold user data in its own memory and shows where to put it.
Caching gets its own part with 4 lessons. Topics are hit ratios, the cache-aside, write-through and write-back patterns, and LRU eviction. The last one tackles stale data: time-based expiry, deleting entries on write, a leftover race condition, and the stampede when a popular key lapses.
Databases, queues and reliability
The data part is the longest at 9 lessons and 85 minutes. It compares SQL and NoSQL stores, shows how a B-tree index finds one row in a billion with a few reads, and works through transactions, replication, sharding and consistent hashing. CAP, PACELC, Raft consensus and object storage finish it.
Next comes async and messaging, with 6 lessons:
- Queues and pub/sub
- Kafka-style event logs
- Idempotency, and how a retry can bill a customer twice
- Delivery guarantees from at-most-once to exactly-once
- Backpressure when load outruns capacity
The reliability part adds 7 lessons: rate limiting with five algorithms, timeouts and retries, circuit breakers, load shedding, health checks and failover, logs, metrics and traces, and SLOs. Watching percentiles instead of averages gets its own argument. So does using the gap below 100% reliability to decide between shipping and fixing.
AI systems and case studies
Five lessons are aimed at people building on language models. One covers LLM gateways, a single service placed ahead of every model provider to manage keys, limits, costs, fallbacks and logs. Another covers vector search, where quick indexes give up a little accuracy for large speed gains. Retrieval-augmented generation, agent loops and production evals round out the set.
In the agent lesson, the model chooses a tool, your code executes it, and the output returns to the model, repeating until the job finishes or a cap is reached. The evals lesson pairs a fixed set of test cases and scoring graders with a gate before each change and sampling of live traffic after release.
Case studies are the least finished part. Only the URL shortener is done, designed from requirements through capacity estimates, the API, key generation, storage, quick redirects and click counting. Six more are listed without content: unique ID generation, a news feed, a chat app, notifications, search autocomplete and video streaming.
Who it suits
This system design course targets developers preparing for architecture discussions or interviews, and anyone who wants a plain-language tour of how big services stay up. Because the simulations run in the browser, you can test an idea such as removing a cache or lowering a rate limit and see the effect right away. Each lesson has its own reading time, so you can pick one topic without committing to the full seven hours.
What’s still missing
The course lists 50 lessons in total, so 6 are still to come, all of them case studies. The author accepts issues and pull requests, which suggests the remaining designs and any corrections may arrive through the public repository. Until then, the 44 finished lessons cover the foundations through AI systems, and the URL shortener is the only complete worked design.
If you’re new to the topic, the first part is the natural starting point. It takes 53 minutes, and the later lessons build on its latency numbers and estimation habits.
Source: systems-design.aiengineer.co