Skip to content
Rabat, Morocco
Posts

2026 Edition: 50 System Design Concepts (Quick Reference)

December 12, 2025
2026 Edition: 50 System Design Concepts (Quick Reference)
System design is not hard because the ideas are “too advanced”. It’s hard because the concepts are scattered: one blog post for caching, a YouTube video for queues, a random thread for CAP, and an interview guide that assumes you already know half the terms. So here’s a single, beginner-friendly quick reference: 50 system design concepts you’ll keep hearing in real architecture conversations.
  • Skim it in one sitting, or
  • Bookmark it and come back when a term shows up in a meeting or an interview.
I’ll keep the explanations short, practical, and opinionated enough to be useful.
  • Skim (10 minutes): read the headings + first sentence.
  • Study (30–45 minutes): pause on anything unfamiliar and search one example.
  • Interview drill (5 minutes): explain 5 concepts out loud (definition → trade‑off → example).

  • Vertical: bigger machine.
  • Horizontal: more machines.
  • Horizontal wins long-term, but forces you to handle coordination, statelessness, and failure.
  • Latency: how fast one request finishes.
  • Throughput: how many requests per second.
  • You can increase throughput and still make users miserable if tail latency is bad.
Averages lie. Design for p95/p99 because that’s what users feel at scale. When the network partitions, you trade off Consistency vs Availability. Even without a partition, you still trade Latency vs Consistency.
  • ACID: strict transactions, correctness first.
  • BASE: availability + eventual consistency, correctness converges over time.
  • Many real systems use both: money = ACID, feeds/analytics = BASE.
Stateless services scale and recover easier. Stateful services can be simpler… until they aren’t. The more services depend on each other, the more failures cascade. Boundaries are a reliability feature. If the same request is retried, it should not double-charge, double-create, or double-send. When downstream is slow, you must slow down upstream (queues, rate limits, shedding) or the whole system collapses.
Distributes traffic and removes single-instance fragility. Round robin, least connections, weighted, consistent-hash (for stickiness). Pick based on workload.
  • Reverse proxy: represents servers.
  • Forward proxy: represents clients.
A reverse proxy for APIs: routing, auth, rate limits, observability. Keep it thin. How services find each other as instances scale up/down (DNS, registry, sidecars). Retries without timeouts = pile-ups. Timeouts without retries = fragile. You need both, plus limits. Stop hammering a failing dependency; fail fast and recover gracefully. Better performance via multiplexing (HTTP/2) and QUIC over UDP (HTTP/3) to reduce handshake pain.
  • REST: simple and universal.
  • gRPC: typed contracts, streaming, efficient service-to-service.
  • WebSocket: two-way realtime.
  • SSE: server-to-client stream (simpler).

Start by defining: write patterns, read patterns, transactions, latency needs, growth curve.
  • B-Tree: great for reads and ranges.
  • LSM: great write throughput; reads are more work.
Durability: record intent first, then apply. Also powers replication streams. Normalize for correctness; denormalize for read performance when joins become expensive. Split data across nodes. The shard key is everything—bad keys create hot shards. Data moves when shards change. This is why sharding is an operational commitment. Copies data across nodes for availability/read scale. Expect lag and conflict tradeoffs. Strong consistency is simpler to reason about; eventual consistency is often easier to scale. Minimizes remapping when nodes join/leave. Common in caches and sharded systems. Use multiple stores on purpose: SQL for transactions, Redis for caching, search for text, etc.
App reads cache first; on miss, load from DB and populate cache. Cache becomes part of the data path. Simpler for apps, more responsibility on cache layer. Caching is easy. Cache invalidation is where you earn your salary. Many requests miss at once and crush DB. Fix with request coalescing, jittered TTLs, locking. One key gets hammered (celebrity profile, trending post). Fix with sharding, replication, or special handling. Push static and cacheable content closer to users (and away from your origin).
  • Pagination is simpler for stability and caching.
  • Infinite scroll is nicer UX but can be expensive and tricky.
Saves bandwidth, costs CPU. Great for large payloads, logs, and replication streams. Batch writes/events to reduce overhead, but be careful with latency and failure semantics. Move slow work off the request path (queues, jobs) to keep p99 under control.
Buffers work and decouples producers/consumers. Also introduces ordering and retry realities. Most systems are at-least-once in practice, so you need idempotency. When retries keep failing, park the message for inspection instead of burning the system. Useful, but easy to misuse. Prefer simpler designs when possible. One leader coordinates (e.g., scheduled jobs). Plan for leader failure and handover. Logs, metrics, traces. If you can’t see it, you can’t run it. Define reliability targets, then use error budgets to balance shipping features vs stability. Protects your APIs and your wallet. Helps against abuse and accidental traffic spikes.
  • AuthN: who are you?
  • AuthZ: what are you allowed to do?
Ask “how can this fail, and how can it be abused?” early. It’s cheaper than post-incident fixes.
Pick any concept above and answer in this format:
  1. Definition (one sentence)
  2. Why it exists (the pain it solves)
  3. Trade-offs (what you pay)
  4. Example (one real system)
If you can do that for 10 concepts, you’re already ahead of most candidates.

Enjoyed this blog?

Seriously, thank you for spending your time here. If you made it to the end, you’re the kind of person who cares about craft, not just quick fixes.If you’d like to support my work, pick one (no pressure). It genuinely helps me keep writing and improving these blogs.
Subscribe to get a heads-up when I publish the next one. I keep it low-volume, and I only send what I’d personally want to read.

Subscribe to Josias's Newsletter

I occasionally write about software engineering, technology, and share thoughts on innovation and engineering.
One last thing: if you know someone who’d benefit from this, sharing it with them is one of the best compliments you can give. I appreciate you.