System Design learning path: everything to study, topic by topic

Functional vs non-functional requirements, capacity estimation, SLA definition, and constraint identification

REST conventions, resource modeling, HTTP methods, status codes, versioning, and pagination

Entity relationships, normalization, denormalization, schema design, and indexing basics

Cache-aside, write-through, write-behind patterns, TTL, eviction policies, and cache invalidation

Protecting APIs and shared resources from excess traffic with token bucket, leaky bucket, fixed and sliding window algorithms, distributed counters, rate limit headers and HTTP 429 responses

Generating globally unique identifiers in distributed systems: UUID versions, database ticket servers, Snowflake-style bit layouts, time-ordered and k-sortable IDs, and the role clocks play in ordering

Back-of-the-envelope estimation of request rates, storage, bandwidth and latency orders of magnitude, used to size a system and sanity-check a design before building it.

Why clocks in distributed systems drift, jump and disagree, and how wall-clock versus monotonic time, leap seconds, logical clocks, bounded-uncertainty time such as TrueTime and certificate expiry shape the correctness of timeouts, leases, ordering and transactions.

Scale-up vs scale-out strategies, stateless design, session management, and auto-scaling

Layer 4 vs layer 7, algorithms (round-robin, least connections, consistent hashing), health checks

Sharding strategies, shard keys, rebalancing, cross-shard queries, and replication

Content delivery networks, edge caching, push vs pull CDN, origin shielding, edge functions

Health checks, metrics collection, distributed tracing, log aggregation, alerting, SLI/SLO/SLA, and observability pillars

How hash rings, virtual nodes and related schemes spread keys over changing sets of servers with minimal remapping, and how to handle hot spots, replication and load bounds in caches, sharded stores and load balancers.

How servers keep many long-lived client connections open and push data over them: WebSocket, long polling and server-sent events, presence, fan-out of messages across connection-holding servers, and routing and reconnection behaviour

How DNS resolution, caching, GeoDNS, BGP route advertisement and anycast decide how user traffic reaches a system, and how failures in names or routes can take a healthy service off the internet.

Consistency, availability, partition tolerance trade-offs, PACELC, eventual consistency

Paxos, Raft, leader election, quorum-based replication, and split-brain prevention

Two-phase commit, saga pattern, compensating transactions, idempotency, and outbox pattern

Pub/sub, point-to-point, Kafka, RabbitMQ, SQS, ordering guarantees, and dead letter queues

Strong vs eventual consistency, causal consistency, linearizability, quorum reads/writes, and consistency-availability trade-offs

Active-active and active-passive topologies, replication strategies, failover, health checks, graceful degradation, and circuit breakers

REST vs RPC, gRPC, WebSocket, Server-Sent Events, GraphQL, message brokers, and API gateway patterns

Idempotency keys, at-least-once delivery, exactly-once semantics, deduplication, HTTP method idempotency, and retry safety

Replication without a designated leader: tunable read/write quorums, sloppy quorum with hinted handoff, vector clocks for conflict detection, gossip-based membership, and Merkle-tree anti-entropy

Running work later or periodically across many machines: distributed cron, delayed queues, visibility timeouts, at-least-once delivery, and deduplication so that retries and failovers stay safe

How leases, fencing tokens and consensus-backed lock services such as Chubby, ZooKeeper and etcd provide mutual exclusion across machines, and why process pauses, network delays and clock errors make timeout-based locks unsafe unless the protected resource checks them.

SQL vs NoSQL, document stores, key-value, column-family, graph databases, and polyglot persistence

Batch vs stream processing, ETL/ELT, Lambda/Kappa architecture, data lakes, and data warehouses

Inverted indexes, Elasticsearch, full-text search, ranking algorithms, and search relevance

Time-series databases, downsampling, retention policies, InfluxDB, Prometheus, and metric aggregation

Double-entry bookkeeping, immutable append-only ledgers, idempotent posting, and reconciliation of internal records against payment service provider settlement data

How to stop two buyers from getting the same seat, room or unit of stock: atomic conditional writes, optimistic and pessimistic locking, constraints that reject overlaps, and time-limited holds that expire and release safely.

How to move live data to a new schema or datastore without downtime or loss: dual writing, backfill, shadow reads, verification, cutover and rollback, and how to sequence them so every step stays reversible.

How concurrent edits to a shared document converge on every client: operational transformation versus CRDTs, last-writer-wins at property level, ordering through a central server, tombstones, tree and sequence structure, and offline reconciliation.

How to assemble home timelines and news feeds for many readers: fan-out on write versus fan-out on read, the celebrity and hot-key problems, hybrid timelines, precomputed feed caches, async fan-out workers and the ranking step on top of candidate posts.

How databases lay data out on disk and keep it durable and consistent: B-tree and LSM-tree designs, write-ahead logging, memtables, SSTables and compaction, write, read and space amplification, and multiversion concurrency control, plus how to pick an engine for a workload.

How geohash, quadtrees and the S2 and H3 cell systems turn locations into indexable cell identifiers so that nearby-search becomes a handful of key lookups, and how to handle cell boundaries, uneven density, resolution choice and sharding of spatial data.

How Bloom filters, HyperLogLog and Count-Min Sketch answer membership, distinct-count and frequency questions in small, fixed memory by accepting controlled error, and how to size them, merge them and decide where approximation is safe in real systems.

Service decomposition, bounded contexts, API gateways, service mesh, and migration strategies

Command-query separation, event stores, projections, snapshots, and temporal queries

Bounded contexts, aggregates, domain events, ubiquitous language, and context mapping

FaaS, event-driven patterns, cold starts, step functions, and serverless data stores

Common performance mistakes including N+1 queries, chatty I/O, missing caching, synchronous bottlenecks, and thundering herd

Ambassador, sidecar, strangler fig, bulkhead, saga, CQRS implementation, event sourcing, and retry patterns for cloud-native systems

Keeping a service useful when demand exceeds capacity: backpressure, load shedding, retry budgets, metastable failures, and avoiding stampedes during recovery.

Partitioning a system into isolated, independent cells (or pods) and using shuffle sharding to shrink the blast radius of failures, with a thin routing layer and a clear split between control plane and data plane.

How to ship code, configuration and data changes to production with a limited blast radius: blue-green, rolling and canary releases, feature flags and kill switches, automatic rollback, bake time, backward-compatible changes, and staggered rollouts by region, zone and cell.

Designing for billions of users, data partitioning at scale, global consensus, and edge architectures

Active-active, active-passive, data replication, latency optimization, and failover strategies

RPO/RTO, backup strategies, chaos engineering, runbooks, and business continuity planning

Cost modeling, reserved capacity, spot instances, right-sizing, and FinOps practices

Designing end-to-end ML systems: feature stores, training pipelines, serving infrastructure, and model lifecycle management

Building systems that comply with GDPR, PCI-DSS, SOC 2, and HIPAA — from data flows to audit trails

Designing and running chaos experiments to proactively discover system weaknesses before they cause production incidents

Designing real-time analytics systems using stream processing, CQRS, and lambda/kappa architectures

Designing cost-efficient architectures: unit economics, right-sizing, spot instances, and FinOps collaboration patterns

How large binary objects and video travel from client to storage and back: multipart and resumable uploads, transcoding pipelines, adaptive streaming over HLS or DASH, CDN cache hierarchies, and object storage that balances metadata cost, durability and access temperature.

How large-scale recommenders narrow a huge catalog with candidate generation and then order a short list with a ranker, and how to handle implicit feedback, cold start, objectives, blending of candidate sources and offline versus online evaluation.

How embedding-based retrieval is served in production: approximate nearest neighbor indexes (graph, inverted-file and quantization families), the recall versus latency trade-off, keeping indexes fresh under inserts, deletes and model changes, and combining vector search with filters and term matching.

How LLM inference servers batch requests at the iteration level, manage the KV cache with paged memory, separate prefill from decode, stream tokens to clients, and balance time to first token, per-token latency and throughput on GPUs.

How to design retrieval-augmented generation systems end to end: ingesting and chunking documents, hybrid retrieval with fusion and reranking, grounded and cited answers, quality evaluation, and keeping the index fresh and access-controlled.

How transformers and attention, tokenization, context windows and diffusion models work inside, and what that implies for designing systems that serve generative models: latency, memory, cost and answer quality.

How to judge machine learning and LLM systems before and after launch: offline versus online metrics, A/B tests, shadow and canary releases, drift and silent-failure detection, model regression gates and LLM evals including judge-model pitfalls.

How to design layered defenses around LLM applications and agents: input and output filters, safety classifiers, prompt injection defenses, moderation policy, red teaming, human approval and limits on autonomy, plus the failure modes of both lax and over-strict guardrails.

How feature stores and the data pipelines behind them serve the same features to training and to online inference: offline and online stores, training-serving consistency, point-in-time correct joins, backfills, materialization and feature freshness.

How large models are trained across many accelerators: composing data, tensor and pipeline parallelism, sharding and recomputing memory, checkpointing without stalling the job, gang scheduling shared GPU clusters, surviving failures and stragglers, and reading utilization metrics to control cost.

How text-to-image, text-to-video and text-to-audio services are built on diffusion pipelines, and how job queues, GPU workers and batching, latency controls, moderation and unit cost shape the serving architecture.

How to design systems in which an LLM directs a loop of tool calls: when to prefer workflows over agents, tool design, planning, tiered memory, multi-agent orchestration, durable execution, evaluation, observability and limits on autonomy and permissions.