System Design — SLAM OG¶

The OG's guide to building systems that actually scale.

This course rebuilds system design from first principles, in plain language. No buzzword bingo. No corporate hand-waving. Real engineering decisions and the trade-offs they cost.

Each topic delivers:

A 1-line hook — why this matters
The core concept in 8 minutes or less
A diagram you can sketch on a napkin
A real-world example (Netflix, Twitter, Stripe — wherever the pattern actually shows up)
A "test yourself" quiz embedded in the page metadata

The same content powers the SLAM OG System Design app — one source, two consumers.

Foundation tier¶

The ~15 things every backend engineer should be able to explain in their sleep. The order matters — networking before load balancers, caching before CDNs, SQL before sharding.

Networking & protocols

Networking Fundamentals — The internet is just envelopes inside envelopes. Learn the stack, see the system.
HTTP Fundamentals — The vocabulary of the web. Verbs, codes, and headers — that's the whole game.
URLs, URIs, URNs — Everyone uses these three letters wrong. Here's the actual hierarchy.
DNS & Internet Traffic Routing — DNS is the phonebook for the internet — except no one's in charge, and somehow it still works.
Latency Numbers Every Engineer Should Know — L1 cache: 0.5ns. Cross-continent: 150ms. Same factor that makes your code fast or slow.

Speed & distribution layer

Load Balancers — Traffic cop for your servers. No load balancer, no scale.
Proxy vs Reverse Proxy — A proxy hides clients. A reverse proxy hides servers. Same trick, opposite direction.
Content Delivery Network (CDN) — Move the content closer to the user. Latency drops. Origin breathes.
Caching Strategies — Why ask twice? Caching is the laziness that makes systems fast.
Redis & In-Memory Data Stores — RAM speed, with a knob for how much durability you can afford to lose.

Data layer

SQL Fundamentals — Sixty years in, still the lingua franca of data.
Database Types (SQL, NoSQL, and Beyond) — Fit, not religion. Pick the database that matches how you read and write.
ACID, CAP, and BASE — Three acronyms decide what your database can actually promise.
Database Sharding — When one DB isn't enough, split it — carefully. You don't get to undo this.
Object Storage — Cheap, durable, infinite — and the wrong tool for half the things people use it for.

Foundation tier complete.

Patterns tier¶

The composable building blocks — auth, API design, distributed coordination, cloud infrastructure.

Auth & security

Cookies, Sessions, and Tokens — Three ways to remember who you are. Pick by who holds the state.
OAuth 2.0 and JWT — Delegation plus signed receipts. One app acting for a user, with proof.
HTTPS, SSL/TLS, and Encryption — Identity and secrecy, agreed in one handshake.

API design

REST API Design & Authentication — REST isn't a spec, it's a vibe. Predictable conventions are the product.
API Styles Compared — Different tools for different conversations. Match the style to the call pattern, not the hype.
GraphQL Deep Dive — Ask for exactly what you need. Get exactly that. One round trip.
gRPC Deep Dive — HTTP/2 plus Protobuf plus codegen. The trifecta that owns the data center.
Webhooks vs Polling — Stop asking. Get called back.
API Gateway — One front door. Many backends. Cross-cutting concerns handled once.

Distributed patterns

Microservices Architecture — An org problem, not a tech problem. Don't take the trade until you have the problem.
Message Queues & Brokers — Drop the message, walk away. The broker delivers — eventually.
Event Sourcing & Event-Driven Architecture — Don't store what is. Store what happened. State becomes a function of history.
Distributed System Patterns — Survival tools for the chaos. Distributed systems lie — these patterns are how you survive the lies.
Observability — Logs, Metrics, Traces — Three pillars turn 'it's broken' into 'here's why' — without SSH-ing into 30 boxes.

Cloud & infrastructure

Containers & Docker — Package the app and its world. Same image, anywhere.
Kubernetes — Declarative orchestration. You describe the cluster you want; k8s makes it real.
Cloud-Native Architecture — Design for the cloud, not in spite of it.
CI/CD Pipelines — Small changes, automated safety, ship daily. The big-batch release is dead for a reason.

Patterns tier complete.

Real systems tier¶

Case studies of how real companies built their architectures. Where the gamification gets fun in the SLAM OG app — "design X" challenges, "why did they pick Y?" deep dives.

Case: Netflix Architecture — The company that taught the cloud how to fail well.
Case: Uber Architecture — Real-time matching at planet scale.
Case: Twitter Architecture — The fan-out problem solved hybrid push/pull.
Case: Slack Architecture — The notification decision tree is the product.
Case: Discord — Trillions of Messages — They picked the right database family — eventually.
Case: Stack Overflow Architecture — 1.3B pageviews/month from 9 servers, no microservices.
Case: Payment Systems Architecture — Money plus distributed systems is the hardest problem in tech.
Case: Scaling a Web App to Millions — From one box to a million users, in seven steps.
Case: Amazon Brazil Build System — Build determinism is the foundation under everything.

All 41 topics complete. 🎉

Patterns tier (coming soon)¶

Microservices, message queues, pub/sub, API gateway, event sourcing, CQRS, sagas, circuit breakers, rate limiting, idempotency.

Real systems tier (coming soon)¶

The case studies — design Twitter, design Uber, design Netflix, design Stripe. Where the gamified app gets fun.

How this is built¶

Source PDFs are extracted to a private study/ folder (gitignored), read for context, then rewritten in SLAM OG voice with new diagrams. Original figures are never republished. See STUDY.md for the workflow.