System Design Power-Guide 2025

You don't need another 300-link dump. You need a sequence. Learn the few pillars that show up in every interview and every production incident, then branch out with purpose. This guide gives you that path - topic by topic, with crisp reasons and curated jump-off points.

---

1. API and Web Basics (Non-Negotiable)

• What to know: HTTP lifecycle, headers, caching, TLS, proxies, API styles (REST, GraphQL, gRPC).
• Why it matters: Every system is a networked system; poor API design cascades into scale and reliability issues.
• Study path: Short/long polling vs SSE vs WebSocket, Reverse Proxy vs API Gateway, pagination patterns, versioning, idempotency.

2. Caching and Performance

• What to know: Local vs global caches, eviction policies (LRU/LFU), stampede protection, TTL design.
• Why it matters: Most systems fail first on read latency under load; cache correctness affects data trust.
• Study path: CDN internals, Redis persistence and performance, cache invalidation strategies, autocomplete and search caching.

3. Databases and Storage

• What to know: SQL vs NoSQL, sharding, replication, consistency levels, LSM vs B-Tree, time series trade-offs.
• Why it matters: Partition keys, indexes, and replica topology decide your bottlenecks and blast radius.
• Study path: Dynamo-style KV, Cassandra/Bigtable, Postgres replication, CDC, object storage and durability (S3).

4. Messaging and Streams

• What to know: Queues vs logs, delivery semantics, consumer groups, backpressure, idempotency/outbox.
• Why it matters: Most scalable systems are event-driven; failures hide in retries and ordering.
• Study path: Kafka fundamentals, DLQ patterns, stream processing, exactly-once myths and practical "effectively-once".

5. Compute and Orchestration

• What to know: Containers, scheduling, autoscaling, blue/green and canary, rollbacks.
• Why it matters: Releases and elasticity are reliability features, not ops afterthoughts.
• Study path: Kubernetes services and patterns, CI/CD flows, IaC hygiene, fault injection.

6. Cloud and Scalability

• What to know: Horizontal vs vertical scaling, multi-AZ/region patterns, resiliency, cost controls.
• Why it matters: "Works on my laptop" ends the moment traffic spikes or a zone blips.
• Study path: Load balancers, rate limiting, retries with jitter, distributed locks, unique ID generators, HA playbooks.

7. Security and Auth

• What to know: OAuth/OIDC, sessions vs JWT, token storage, TLS, secrets management.
• Why it matters: Auth bugs become front-page outages; PCI/PII rules affect architecture.
• Study path: Permission models, token lifecycles, password storage, mTLS, API hardening.

8. Observability and Operations

• What to know: Metrics, logs, traces, SLOs, error budgets, incident flow.
• Why it matters: You cannot scale what you cannot see; design for debugging from day one.
• Study path: Time-series storage, sampling, cardinality strategies, structured logging, trace-based debugging.

---

Curated Jump-Off List (Start Here)

Below is a compact set of representative topics to explore in each area. Use these as prompts to find official docs and deep dives.

API and Web

• How HTTP/2 and HTTP/3 change latency.
• REST vs GraphQL vs gRPC trade-offs.
• API Gateway vs Reverse Proxy.
• Pagination patterns and pitfalls.

Real Systems to Dissect

• Twitter timeline ranking and search signals.
• YouTube upload pipeline and CDN fanout.
• Netflix caching and data stores.
• Discord trillions-of-messages storage.

Databases

• Sharding algorithms and partition keys.
• Dynamo-style KV internals.
• LSM tree vs B-Tree fundamentals.
• Read replicas and lag management.

Messaging

• Kafka consumer groups and offsets.
• Delivery semantics and DLQ strategies.
• CDC and stream processors.
• Fanout patterns for notifications.

Cloud & Scale

• AWS typical network blueprints.
• Autoscaling and graceful degradation.
• Multi-region: routing, config, drift.
• Distributed locks and fencing tokens.

Security

• OAuth flows and token lifetimes.
• Sessions vs JWT storage trade-offs.
• TLS handshake and pinning.
• Designing enterprise authorization.

Observability

• High-cardinality metrics at scale.
• Trace sampling and correlation.
• Alerting vs SLO-based burn alerts.
• Incident review checklists.

---

How to Practice (Weekly Repeatable Loop)

• Pick one system (e.g., URL shortener).
• Define API, data model, scaling plan, and failure modes.
• Do back-of-the-envelope capacity estimates.
• Write down cache keys, TTLs, and invalidation rules.
• Decide which paths must be strongly consistent vs eventually consistent.
• Review trade-offs with a buddy or rubber-duck it in a doc.

Interview Mode (Signals Interviewers Look For)

• Clear requirements and constraints.
• Data model and partition keys aligned with access patterns.
• Caching strategy that avoids stampede and staleness traps.
• Thoughtful trade-offs: fanout vs fan-in, write vs read, latency vs cost.
• Resiliency plan: retries, idempotency, DLQs, circuit breakers.
• Evolution plan: MVP first, then shards, then regions.

---