Don't read
system design.
Operate it.
An interactive atlas of modern engineering — system design, AI, databases, networking and more. Every concept is a diagram that builds itself as you scroll, so the ideas click instead of just being read.
8 tracks through modern engineering
System Design
Scale, caching, queues and the architectures behind the products you use daily.
What happens when you type google.com
The single most-asked interview question, animated end to end.
A crash course on scalability
How one box on a laptop becomes a system that serves millions.
Load balancer vs API gateway vs reverse proxy
Three boxes that sit in front of your servers — and do very different jobs.
Where do we cache — and how it goes wrong
Caching lives at every layer. So do the ways it can bite you.
How Netflix built a distributed counter
Counting sounds trivial — until it has to be right at global scale.
10 components of a production web app
The ten boxes that stand between a user's click and your database.
How to design a system like Instagram
Photos are the easy part — the feed is where the real system design lives.
The evolution of scaling at Netflix
From shipping DVDs to streaming a third of the internet — one architectural leap at a time.
What is event sourcing
Instead of storing where you are, store how you got there.
How CQRS works
Reads and writes want different things — so give them different models.
How data lake architecture works
One place to land any data now and decide what it means later.
What are modular monoliths
The clean boundaries of microservices without the distributed-systems tax.
How Amazon S3 works
An effectively infinite hard drive on the internet, with eleven nines of durability.
Server types you should know
Nine specialised servers, and the one job each of them exists to do.
System performance metrics every engineer should know
Averages lie; percentiles and the golden signals tell you the truth.
How to load websites at lightning speed
The bytes you never send, the trips you never make: a tour of every layer that makes a page feel instant.
How to debug a slow API
Measure before you guess: a disciplined walk down the request path to find where the milliseconds go.
SQS vs SNS vs EventBridge vs Kinesis
Four AWS messaging services, four different jobs — queue, fan-out, event bus, and stream.
How RabbitMQ works
A smart broker that routes each message from producer to the right queue — the classic AMQP message broker.
Apache Kafka vs RabbitMQ
A replayable log versus a smart routing broker — two philosophies of moving messages at scale.
Design patterns every developer should know
Named, reusable solutions to problems that keep reappearing in object-oriented design.
Clean code principles
Code is read far more often than it is written — clean code optimizes for the reader.
The testing pyramid
A shape that tells you how many of each kind of test to write — and why.
Best practices for microservices
Splitting a system into services only pays off if you follow the rules that keep them independent.
The SOLID principles
Five object-oriented design rules that keep code flexible instead of fragile.
Concurrency is not parallelism
Dealing with many things at once is a different idea from doing many things at once.
Process vs thread
Two ways to run code at once — one isolated and safe, one shared and fast.
Batch vs stream processing
Process the data after it piles up, or the instant it arrives.
How clean architecture works
Concentric rings of code where every dependency points toward the business rules.
Key terms in domain-driven design
A shared language and a toolkit of patterns for modeling complex business domains.
Algorithms for system design
The handful of algorithms and data structures that keep showing up inside real distributed systems.
Coding patterns for interviews
Most interview problems are variations on a dozen reusable patterns — learn the patterns, not the problems.
Networking
How bytes actually move — DNS, TCP, TLS, HTTP and the protocols underneath.
HTTP/1 → HTTP/2 → HTTP/3
Three generations of the web's request protocol, each killing the last one's bottleneck.
How HTTPS works
The TLS handshake that turns a plain TCP connection into a private, verified channel.
TCP vs UDP
Reliable and ordered, or fast and best-effort — the transport trade-off.
How DNS works
Turning a human name into a machine address by walking a global hierarchy.
Latency vs throughput
How fast one thing finishes versus how many things finish per second.
The structure of a URL
Every address on the web is a packed little instruction set — decode it once and read it forever.
Common HTTP status codes
Three digits that tell you, at a glance, exactly how a request went.
HTTP vs HTTPS
The single letter that turns an open postcard into a sealed, verified envelope.
Forward proxy vs reverse proxy
Two middlemen with mirror-image jobs: one fronts the clients, one fronts the servers.
Can a web server push real-time updates?
Four ways to move fresh data from server to browser, from crude polling to a live socket.
What is a firewall
The gatekeeper that decides which packets are allowed to cross a network boundary.
Common network protocols every engineer should know
The dozen protocols that quietly carry every request you make, sorted by the layer they live on.
Common ports worth knowing
The port numbers that tell you which service is listening — memorize these and half of networking clicks.
IP addresses explained
The addressing scheme that lets any machine on Earth find any other.
Hub, switch and router explained
Three boxes that look alike but work at completely different layers.
Why Nginx is so popular
One event loop that quietly handles tens of thousands of connections at once.
Network debugging commands every engineer should know
A toolkit that walks a broken connection from your machine out to the server.
Databases
Indexes, joins, normalization and how a query becomes an answer.
Database index types
The data structures that turn a full-table scan into a pinpoint lookup.
The 4 types of SQL join
Inner, left, right, full — which rows survive when two tables meet.
The 5 normal forms
A ladder of rules that squeezes redundancy out of a schema, one dependency at a time.
How a SQL query executes
The pipeline that turns a text string into rows fetched off disk.
Redis vs Memcached
Two in-memory key-value stores — one a lean cache, one a data-structure server.
PostgreSQL 101
The relational database that quietly became everyone's default.
How MongoDB works
A database that stores JSON-like documents instead of rows and tables.
Comparing key-value stores
Four stores that all map keys to values — and almost nothing else in common.
Database types you should know
A field guide to the eight database families and when each one wins.
How to improve database performance
A ladder of moves that takes a slow query from seconds to microseconds.
Which database should I use on AWS
Seven managed engines, one rule — match the database to the shape of your data and access pattern.
The data structures behind databases
Every database is a clever arrangement of a few data structures chosen for how you read and write.
The life of a Redis query
Follow one command from your client to a reply — and see why single-threaded is a feature, not a bug.
Security & Auth
Sessions, tokens, OAuth, SSO and the attacks they defend against.
Sessions, cookies, JWT & OAuth 2.0
How a server remembers who you are — and who let you in.
How SSO works
One login, many apps — because everyone trusts the same doorman.
How two-factor authentication works
A password can be stolen. A second, independent factor is much harder to steal too.
SQL injection
When user input becomes code, your database does the attacker's bidding.
JWT explained
A signed, self-describing token that lets a server trust a request without looking anything up.
JWT vs PASETO
One format gives you infinite flexibility and a loaded footgun; the other takes the gun away.
Cross-site scripting (XSS)
Trick a trusted site into serving your JavaScript, and it runs with the victim's session.
Access control explained
First prove who you are, then the system decides what you're allowed to touch.
Top tips for API security
An API is a door into your data — these are the locks every one of them needs.
REST API authentication methods
Six ways to prove who's calling your API — and what each one costs you.
Tokens vs API keys
One names an application, the other names a session — and that difference decides everything.
AI & LLMs
Transformers, RAG, agents and MCP — the applied-AI stack, demystified.
How the Transformer architecture works
The architecture behind GPT, Claude, Gemini and Llama — one block at a time.
What is Retrieval-Augmented Generation (RAG)
Ground an LLM in your own data so it stops making things up.
How AI agents chain tools, memory & reasoning
An LLM in a loop that plans, acts, observes — and keeps going until it's done.
What is MCP (Model Context Protocol)
One open protocol that connects AI apps to any tool or data source — USB-C for AI.
Fine-tuning vs LoRA vs RAG
Three ways to specialize an LLM — and when each one is the right call.
How large language models work
The machine that learned to talk by predicting the next word, a trillion times over.
How LLMs see the world (tokens & embeddings)
To a model, your prompt isn't words — it's a list of numbers with a strict budget.
AI vs ML vs deep learning vs generative AI
Four nested circles that get thrown around interchangeably — untangled with one example each.
RAG vs Agentic RAG
Classic RAG looks things up once. Agentic RAG hires a researcher who keeps digging until the answer holds up.
Types of AI agents
From a thermostat's reflex to a fleet of LLMs planning together — the same word, very different minds.
MCP vs API vs A2A protocol
Three connectors for three different conversations — apps, models, and agents.
How Generative Adversarial Networks work
Two neural networks locked in a forger-versus-detective duel until the fakes become indistinguishable.
6 steps to create an AI model
The end-to-end lifecycle from a fuzzy problem to a monitored model in production.
DevOps & Cloud
Containers, Kubernetes, CI/CD and streaming — how code ships and runs.
How Docker works
Package an app and everything it needs into one portable, isolated unit.
How Kubernetes works
You declare the desired state; the cluster relentlessly makes it real.
CI/CD pipeline explained
Turn every commit into a tested, shippable, deployable artifact — automatically.
How Apache Kafka works
A distributed commit log that decouples who produces data from who consumes it.
Virtualization vs containerization
Two ways to slice one machine into many — a whole fake computer, or just a fenced-off process.
Types of virtualization
Virtualization isn't just servers — you can fake the kernel, the network, the disk, and the desktop too.
Git vs GitHub
One is the version-control engine on your laptop; the other is the social cloud built around it.
Git branching workflows
The commit-to-merge loop every team runs — and the branching models that shape it.
How git reset works
One command, three trees, and the difference between undo and disaster.
Docker vs Kubernetes
Not a rivalry — one packages a container, the other runs thousands of them.
The lifecycle of a Kubernetes pod
From 'Pending' to 'Running' to a graceful goodbye — how a pod actually lives and dies.
Kubernetes scaling strategies
Five levers for meeting demand — from a hand-set replica count to event-driven autoscaling.
Infrastructure as code
Describe your servers, networks and databases in files you can review, version and replay.
Docker best practices
The handful of habits that turn a bloated, insecure image into a small, fast, safe one.
Deployment strategies
Five ways to release new code — trading downtime, risk, rollback speed and cost against each other.
APIs
REST, GraphQL and gRPC — the contracts services talk through.
REST vs GraphQL
Two ways to shape an API — resources and endpoints, or one flexible query.
How gRPC works
Call a function on another machine as if it lived in your own process.
API design best practices
The conventions that make an API feel obvious instead of hostile.
Ways to improve API performance
Seven levers that turn a sluggish endpoint into a fast one.
What is a REST API
The architectural style that made the web's APIs feel like the web itself.
API vs SDK
The contract versus the toolkit that makes the contract pleasant to use.
Fundamentals
Memory, threads, data structures, patterns and the languages underneath it all.
How computer memory works
A pyramid of trade-offs: the closer memory sits to the CPU, the faster, smaller and pricier it gets.
How Java virtual threads work
Millions of threads on a handful of OS threads — concurrency without the memory bill.
How Java works
Write once, run anywhere — the compile-to-bytecode-then-run-on-a-virtual-machine trick.
How Java HashMaps work
Turn a key into an array index and you get near-instant lookups — until keys collide.
How Python works
From a .py file to running instructions — and why the GIL shapes everything.
Python vs Java
Two beloved languages with opposite philosophies — scored on the dimensions that matter.
Versioning strategies
Version numbers are a contract — here's how to make them mean something.
Pick a thread and pull
Every concept connects to others. Follow the links at the bottom of each page and let the atlas teach you the map, not just the pins.
Begin the tour