System Designs
Click a layer. See why it exists.
Interactive paths — each flow has its own diagram and its own code. Write paths, deploy on AWS, a request’s blast radius across services, interview walks, language trees you can point at, then AI curricula: fundamentals (ML through domains), advanced generative (LLMs through agents), and the GOD map that is both on one board.
01 · Go
Interactive
Write path · Write-heavy API
Scalable & Low-Latency Go System Design
Invoice creation — sync until commit, then fan out
A create-invoice request that stays fast: validate, authorize, lock, commit — then PDF, email, and analytics leave the hot path.
- Goroutines
- ACID
- Outbox
- Queues
- Redis
- Horizontal scaling
Open flow →
02 · Go
Interactive
Deploy path · Ship & run
Go on AWS: Docker, CI/CD, Lambda
One image → ECR → HTTP + worker Lambdas · two sites on the edge
A Go module becomes one Docker image. CI runs tests and checks, pushes to ECR, then two Lambdas pick it up — cmd/api for HTTP, cmd/worker for the queue. Route 53 and CloudFront put the platform, the client site, and the API on real hostnames.
- Docker
- CI/CD
- ECR
- Lambda
- SQS
- Redis
- Replica
- Route 53
- CloudFront
- S3
Open flow →
03 · AWS
Interactive
Infra path · Blast radius per module
AWS: a request, the services it touches
Thirty-six layers — click a feature, see which boxes run, and which must not
A user intent is not “the server.” Homepage is the edge. Create is gateway, Lambda, Redis, RDS, then SQS send. PDF and email run on the worker after 201. Click a module; the highlighted services are the count.
- Route 53
- CloudFront
- API Gateway
- Lambda
- RDS
- Redis
- SQS
- S3
- SES
- IAM
Open flow →
04 · Go
Interactive
Scale path · Scale & isolation
Scale and dependency failures
10,000 RPS · peak latency · DB saturation · slow payment
Design for 10k RPS, then diagnose peak latency. Identify the bottleneck before you pick a lever — indexes and cache, not a bigger pool; timeouts and a breaker, not hope.
- Horizontal scaling
- p99
- Caching
- Read replicas
- Timeouts
- Circuit breaker
Open flow →
05 · Go
Interactive
Correctness path · Invariants
Concurrency and correctness
Duplicate payments · booking · the last item
The same payment twice, many users on one seat, two buyers and one SKU. Uniqueness, TTL holds, and a single UPDATE … WHERE quantity >= 1.
- Idempotency
- Reservations
- Atomic updates
- Optimistic locking
- Last item
Open flow →
06 · Go
Interactive
Jobs path · Runtime
Jobs and Go runtime safety
A million jobs · memory · unbounded goroutines
Durable queue, bounded pool, poison to the DLQ. Investigate rising RSS with profiles, not GC. Extra goroutines need a ceiling around scarce resources.
- Worker pool
- DLQ
- pprof
- Backpressure
- Graceful shutdown
Open flow →
07 · Go
Interactive
Evolution path · Change
System evolution and deployment
Strangler · zero downtime · expand-and-contract
Extract a module behind a contract, route a slice, keep rollback. Deploy new Go instances with readiness, drain, and graceful shutdown — schema expands before it contracts.
- Strangler
- Outbox
- Rolling
- Blue-green
- Canary
- Expand-contract
Open flow →
08 · Go
Interactive
Language path · Language as a tree
Go: types, concurrency, and the runtime
Forty-nine layers — a package, a goroutine, then channels and the GMP pipeline
A package becomes a process, then the process’s memory: types and methods, slices and maps, error values, then goroutines and channels, then the scheduler — G, M, P — with the traps crossed out.
- Types
- Slices
- Interfaces
- Errors
- Goroutines
- Channels
- Context
- GMP
- Escape analysis
- GC
Open flow →
09 · Python
Interactive
Language path · Language as a tree
Python: types, asyncio, and the runtime
Forty-nine layers — a module, a Task, then queues and the GIL pipeline
A module becomes a process, then the process’s memory: names and objects, lists and dicts, exceptions, then Tasks and queues, then the loop — Task, thread, GIL — with the traps crossed out.
- Names
- Lists
- Protocols
- Exceptions
- asyncio
- Queues
- Cancel
- GIL
- Refcount
- GC
Open flow →
10 · React
Interactive
Composition path · UI as a tree
React: props, composition, hooks, and lifecycle
Fifty-six layers — a function, a tree, then hooks and the mount pipeline
A function becomes a tree, then the tree’s memory: props and composition, useState, then the rest of the hooks, then mount/update/unmount — function pipeline on the left, class methods on the right.
- Props
- Composition
- useState
- useEffect
- useRef
- useMemo
- useContext
- Custom hooks
- Function lifecycle
- Class lifecycle
Open flow →
11 · AI
Interactive
Learning path · Curriculum as a tree
AI fundamentals: ML, deep learning, domains
Sixteen layers — the umbrella, three ML signals, then CNN · RNN · transformer, then NLP · vision · speech · rank
Artificial intelligence reads left to right: how you get a signal, how deep the net is, which sensor you are on, then the job — data, features, train, evaluate, serve — with the magic-and-no-split traps crossed out.
- Supervised
- Unsupervised
- RL
- CNN
- RNN / LSTM
- Transformers
- NLP
- Computer vision
- Speech
- Recsys
Open flow →
12 · AI
Interactive
Learning path · Curriculum as a tree
AI advanced: generative, RAG, agents
Twenty-four layers — tokens through the window, then tools, then retrieval, then adapters, then the application
Generative AI samples; it is not a database. Tokens through the window, then schema and tools, then RAG beside LoRA. The product is a horizontal application lane: agents, memory, MCP, guardrails, eval, and traces.
- LLMs
- Tokens
- Embeddings
- Attention
- RAG
- Tool calling
- LoRA
- Agents
- MCP
- Eval
Open flow →
13 · AI
Interactive
Learning path · Curriculum as a tree
AI GOD flow: the whole map
Thirty-nine layers — ML through serve, then LLMs through observability, two trap bands
The full map on one board, each topic a left-to-right lane. Fundamentals on top, generative below. Transformer the architecture and Transformers the LLM are the same block at two altitudes. Click Evaluate, RAG, or Agents.
- Machine learning
- Deep learning
- Domains
- LLMs
- RAG
- Fine-tuning
- Agents
- MCP
- Guardrails
- Observability
Open flow →