System Atlas
114 concepts · living diagrams · built from the ByteByteGo 2025 archive

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.

live · request lifecyclestage 01/07
Youtype google.comCache checkbrowser · OS · ISPDNS lookuproot → TLD → authTCP handshakeSYN · SYN-ACK · ACKTLS handshakekeys · ciphergoogle.comweb serverHTTP responseHTML · CSS · JSRenderDOM → paint
You type the address
114
Curated concepts
explained end to end
8
Learning tracks
system design → AI
4
Diagram engines
flow · sequence · stack · metric
the map

8 tracks through modern engineering

SYS

System Design

Scale, caching, queues and the architectures behind the products you use daily.

32 concepts
SYS

What happens when you type google.com

The single most-asked interview question, animated end to end.

7 minCore
SYS

A crash course on scalability

How one box on a laptop becomes a system that serves millions.

8 minCore
SYS

Load balancer vs API gateway vs reverse proxy

Three boxes that sit in front of your servers — and do very different jobs.

6 minApplied
SYS

Where do we cache — and how it goes wrong

Caching lives at every layer. So do the ways it can bite you.

7 minApplied
SYS

How Netflix built a distributed counter

Counting sounds trivial — until it has to be right at global scale.

8 minDeep dive
SYS

10 components of a production web app

The ten boxes that stand between a user's click and your database.

8 minCore
SYS

How to design a system like Instagram

Photos are the easy part — the feed is where the real system design lives.

8 minApplied
SYS

The evolution of scaling at Netflix

From shipping DVDs to streaming a third of the internet — one architectural leap at a time.

7 minApplied
SYS

What is event sourcing

Instead of storing where you are, store how you got there.

8 minDeep dive
SYS

How CQRS works

Reads and writes want different things — so give them different models.

7 minDeep dive
SYS

How data lake architecture works

One place to land any data now and decide what it means later.

8 minApplied
SYS

What are modular monoliths

The clean boundaries of microservices without the distributed-systems tax.

7 minApplied
SYS

How Amazon S3 works

An effectively infinite hard drive on the internet, with eleven nines of durability.

7 minCore
SYS

Server types you should know

Nine specialised servers, and the one job each of them exists to do.

6 minCore
SYS

System performance metrics every engineer should know

Averages lie; percentiles and the golden signals tell you the truth.

7 minApplied
SYS

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.

8 minApplied
SYS

How to debug a slow API

Measure before you guess: a disciplined walk down the request path to find where the milliseconds go.

8 minApplied
SYS

SQS vs SNS vs EventBridge vs Kinesis

Four AWS messaging services, four different jobs — queue, fan-out, event bus, and stream.

7 minApplied
SYS

How RabbitMQ works

A smart broker that routes each message from producer to the right queue — the classic AMQP message broker.

7 minApplied
SYS

Apache Kafka vs RabbitMQ

A replayable log versus a smart routing broker — two philosophies of moving messages at scale.

8 minApplied
SYS

Design patterns every developer should know

Named, reusable solutions to problems that keep reappearing in object-oriented design.

8 minCore
SYS

Clean code principles

Code is read far more often than it is written — clean code optimizes for the reader.

7 minCore
SYS

The testing pyramid

A shape that tells you how many of each kind of test to write — and why.

6 minCore
SYS

Best practices for microservices

Splitting a system into services only pays off if you follow the rules that keep them independent.

8 minApplied
SYS

The SOLID principles

Five object-oriented design rules that keep code flexible instead of fragile.

7 minCore
SYS

Concurrency is not parallelism

Dealing with many things at once is a different idea from doing many things at once.

6 minCore
SYS

Process vs thread

Two ways to run code at once — one isolated and safe, one shared and fast.

6 minCore
SYS

Batch vs stream processing

Process the data after it piles up, or the instant it arrives.

7 minApplied
SYS

How clean architecture works

Concentric rings of code where every dependency points toward the business rules.

7 minApplied
SYS

Key terms in domain-driven design

A shared language and a toolkit of patterns for modeling complex business domains.

7 minApplied
SYS

Algorithms for system design

The handful of algorithms and data structures that keep showing up inside real distributed systems.

9 minApplied
SYS

Coding patterns for interviews

Most interview problems are variations on a dozen reusable patterns — learn the patterns, not the problems.

8 minCore
NET

Networking

How bytes actually move — DNS, TCP, TLS, HTTP and the protocols underneath.

17 concepts
NET

HTTP/1 → HTTP/2 → HTTP/3

Three generations of the web's request protocol, each killing the last one's bottleneck.

7 minApplied
NET

How HTTPS works

The TLS handshake that turns a plain TCP connection into a private, verified channel.

7 minCore
NET

TCP vs UDP

Reliable and ordered, or fast and best-effort — the transport trade-off.

6 minCore
NET

How DNS works

Turning a human name into a machine address by walking a global hierarchy.

6 minCore
NET

Latency vs throughput

How fast one thing finishes versus how many things finish per second.

5 minCore
NET

The structure of a URL

Every address on the web is a packed little instruction set — decode it once and read it forever.

6 minCore
NET

Common HTTP status codes

Three digits that tell you, at a glance, exactly how a request went.

6 minCore
NET

HTTP vs HTTPS

The single letter that turns an open postcard into a sealed, verified envelope.

6 minCore
NET

Forward proxy vs reverse proxy

Two middlemen with mirror-image jobs: one fronts the clients, one fronts the servers.

6 minApplied
NET

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.

7 minApplied
NET

What is a firewall

The gatekeeper that decides which packets are allowed to cross a network boundary.

7 minApplied
NET

Common network protocols every engineer should know

The dozen protocols that quietly carry every request you make, sorted by the layer they live on.

7 minCore
NET

Common ports worth knowing

The port numbers that tell you which service is listening — memorize these and half of networking clicks.

5 minCore
NET

IP addresses explained

The addressing scheme that lets any machine on Earth find any other.

8 minCore
NET

Hub, switch and router explained

Three boxes that look alike but work at completely different layers.

7 minCore
NET

Why Nginx is so popular

One event loop that quietly handles tens of thousands of connections at once.

7 minApplied
NET

Network debugging commands every engineer should know

A toolkit that walks a broken connection from your machine out to the server.

8 minApplied
DB

Databases

Indexes, joins, normalization and how a query becomes an answer.

13 concepts
DB

Database index types

The data structures that turn a full-table scan into a pinpoint lookup.

8 minApplied
DB

The 4 types of SQL join

Inner, left, right, full — which rows survive when two tables meet.

6 minCore
DB

The 5 normal forms

A ladder of rules that squeezes redundancy out of a schema, one dependency at a time.

8 minApplied
DB

How a SQL query executes

The pipeline that turns a text string into rows fetched off disk.

8 minDeep dive
DB

Redis vs Memcached

Two in-memory key-value stores — one a lean cache, one a data-structure server.

6 minApplied
DB

PostgreSQL 101

The relational database that quietly became everyone's default.

8 minCore
DB

How MongoDB works

A database that stores JSON-like documents instead of rows and tables.

8 minCore
DB

Comparing key-value stores

Four stores that all map keys to values — and almost nothing else in common.

7 minApplied
DB

Database types you should know

A field guide to the eight database families and when each one wins.

8 minCore
DB

How to improve database performance

A ladder of moves that takes a slow query from seconds to microseconds.

8 minApplied
DB

Which database should I use on AWS

Seven managed engines, one rule — match the database to the shape of your data and access pattern.

7 minApplied
DB

The data structures behind databases

Every database is a clever arrangement of a few data structures chosen for how you read and write.

8 minDeep dive
DB

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.

7 minApplied
AI

AI & LLMs

Transformers, RAG, agents and MCP — the applied-AI stack, demystified.

13 concepts
AI

How the Transformer architecture works

The architecture behind GPT, Claude, Gemini and Llama — one block at a time.

9 minDeep dive
AI

What is Retrieval-Augmented Generation (RAG)

Ground an LLM in your own data so it stops making things up.

7 minApplied
AI

How AI agents chain tools, memory & reasoning

An LLM in a loop that plans, acts, observes — and keeps going until it's done.

8 minApplied
AI

What is MCP (Model Context Protocol)

One open protocol that connects AI apps to any tool or data source — USB-C for AI.

6 minApplied
AI

Fine-tuning vs LoRA vs RAG

Three ways to specialize an LLM — and when each one is the right call.

7 minApplied
AI

How large language models work

The machine that learned to talk by predicting the next word, a trillion times over.

8 minCore
AI

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.

6 minCore
AI

AI vs ML vs deep learning vs generative AI

Four nested circles that get thrown around interchangeably — untangled with one example each.

5 minCore
AI

RAG vs Agentic RAG

Classic RAG looks things up once. Agentic RAG hires a researcher who keeps digging until the answer holds up.

7 minApplied
AI

Types of AI agents

From a thermostat's reflex to a fleet of LLMs planning together — the same word, very different minds.

7 minCore
AI

MCP vs API vs A2A protocol

Three connectors for three different conversations — apps, models, and agents.

7 minApplied
AI

How Generative Adversarial Networks work

Two neural networks locked in a forger-versus-detective duel until the fakes become indistinguishable.

8 minDeep dive
AI

6 steps to create an AI model

The end-to-end lifecycle from a fuzzy problem to a monitored model in production.

7 minCore
OPS

DevOps & Cloud

Containers, Kubernetes, CI/CD and streaming — how code ships and runs.

15 concepts
OPS

How Docker works

Package an app and everything it needs into one portable, isolated unit.

7 minCore
OPS

How Kubernetes works

You declare the desired state; the cluster relentlessly makes it real.

9 minDeep dive
OPS

CI/CD pipeline explained

Turn every commit into a tested, shippable, deployable artifact — automatically.

7 minCore
OPS

How Apache Kafka works

A distributed commit log that decouples who produces data from who consumes it.

8 minApplied
OPS

Virtualization vs containerization

Two ways to slice one machine into many — a whole fake computer, or just a fenced-off process.

7 minCore
OPS

Types of virtualization

Virtualization isn't just servers — you can fake the kernel, the network, the disk, and the desktop too.

6 minApplied
OPS

Git vs GitHub

One is the version-control engine on your laptop; the other is the social cloud built around it.

6 minCore
OPS

Git branching workflows

The commit-to-merge loop every team runs — and the branching models that shape it.

7 minApplied
OPS

How git reset works

One command, three trees, and the difference between undo and disaster.

6 minCore
OPS

Docker vs Kubernetes

Not a rivalry — one packages a container, the other runs thousands of them.

6 minCore
OPS

The lifecycle of a Kubernetes pod

From 'Pending' to 'Running' to a graceful goodbye — how a pod actually lives and dies.

7 minApplied
OPS

Kubernetes scaling strategies

Five levers for meeting demand — from a hand-set replica count to event-driven autoscaling.

7 minApplied
OPS

Infrastructure as code

Describe your servers, networks and databases in files you can review, version and replay.

7 minApplied
OPS

Docker best practices

The handful of habits that turn a bloated, insecure image into a small, fast, safe one.

6 minApplied
OPS

Deployment strategies

Five ways to release new code — trading downtime, risk, rollback speed and cost against each other.

7 minApplied
start anywhere

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