Articles on the concepts under system design • IndGeek

Articles

One idea per page, usually next to the thing it gets confused with. These are the words a system design answer is built from, and the ones interviewers poke at: what a token actually proves, why "Sign in with Google" is not OAuth, when a 403 should really be a 404, why exactly once delivery does not exist.

Each article stands on its own, takes ten to fifteen minutes, and has something to operate: a simulator, a diagram that plays step by step, or numbers you can drag. Each ends with a mock interview exchange, a checkpoint and the 60 second version to say out loud. The chapters in system design and AI engineering link here when they use one of these ideas without stopping to explain it.

Identity and security#

Authentication vs authorization SSO vs OIDC vs SAML OAuth 2.0 flows Sessions vs JWTs Access tokens vs refresh tokens API keys vs OAuth vs mTLS Hashing vs encryption vs encoding Symmetric vs asymmetric encryption Passkeys vs passwords vs OTP CORS vs CSRF Cookies vs localStorage

Networking and the web#

TCP vs UDP vs QUIC HTTP/1.1 vs HTTP/2 vs HTTP/3 Forward proxy vs reverse proxy vs API gateway WebSockets vs SSE vs long polling REST vs GraphQL vs gRPC What happens when you type a URL L4 vs L7 load balancing

Data and consistency#

Strong vs eventual consistency Optimistic vs pessimistic locking Idempotency keys At most once vs at least once vs exactly once Queue vs pub/sub vs event stream OLTP vs OLAP Push vs pull

Architecture and operations#

Monolith vs microservices Vertical vs horizontal scaling Concurrency vs parallelism Processes vs threads vs async Containers vs VMs vs serverless Blue-green vs canary vs rolling Logs vs metrics vs traces SLA vs SLO vs SLI Rate limiting vs throttling vs backpressure Webhooks vs polling

Working remotely#

The skills that decide how well you do on a team that shares no office and often no time zone: writing that needs no reply, design docs, code review, and owning what you ship at 3am. The remote-ready roadmap puts these in order with the system design and operations chapters a remote team will expect.

Sync vs async communication Design doc vs RFC vs ADR Code review: blocking vs non-blocking Mitigation vs root cause Take-home vs live coding vs pair programming The behavioural round for remote roles

Shipping code#

How a change gets from your editor to users without breaking anything: the tests that catch each kind of bug, the pipeline that runs them on every push, and the flags that let you merge daily and release when you choose. Each shows how teams set it up today, with the tools you will be asked about.

Unit vs integration vs end-to-end tests CI vs continuous delivery vs continuous deployment Feature flags vs long-lived branches

Code design#

The low level design ideas that come in look-alike pairs: the SOLID principles that seem to say the same thing, and the design patterns whose class diagrams are the same picture. Each one is written in TypeScript and builds on the matching chapter in low level design.

Abstraction vs interface vs abstract class The SOLID principles that look alike Dependency inversion vs dependency injection Strategy vs State Adapter vs Decorator vs Proxy vs Facade Factory vs Abstract Factory vs Builder Strategy vs Template Method vs Command Observer vs pub/sub

Design deep cuts#

The ideas that separate a good system design answer from a memorised one: the data structures that count billions of things in kilobytes, pagination that survives a busy table, hot keys, surviving a region, and changing schemas and contracts while everything keeps running. These are part of Pro.

Bloom filter vs HyperLogLog vs Count-Min Sketch Offset vs cursor pagination Cache stampedes, and the four ways to stop one Hot keys and hot partitions Active-passive vs active-active vs cell-based architecture Zero-downtime schema migrations Backward vs forward compatibility

AI engineering#

The choices that come up in every LLM system design round: where your data should go, which of the three caches is saving you money, how a 140 GB model ends up on one GPU, when thinking is worth paying for, how models are tuned to behave, why the biggest models are mixtures of experts, and how to build a voice agent that answers in under a second. They build on the AI engineering path and are part of Pro.

RAG vs fine-tuning vs long context How to fine-tune a model on your own PC KV cache vs prompt caching vs semantic caching FP16 vs INT8 vs INT4 quantization Reasoning models vs standard models SFT vs RLHF vs DPO Dense models vs mixture of experts Voice agents: cascaded vs speech-to-speech