System Design

The recurring building blocks of designing systems at scale — load balancing, replication, partitioning, consistency, and the trade-off vocabulary.

Caching strategies, invalidation, eviction, and the failure modes — from CPU lines to CDNs and distributed caches.

The pattern language of async and distributed systems — messaging, sagas, outbox, idempotency, retries, and delivery guarantees.

Decomposing a system into independently deployable services — when it pays, what it costs, and the patterns that make it survivable.

Designing service contracts — REST done properly, gRPC, GraphQL, versioning, and evolving APIs without breaking consumers.

The contract-artifact formats — OpenAPI, AsyncAPI, protobuf, GraphQL SDL — and the generate-doc-from-code vs generate-code-from-doc trade, with integration notes per Java, Go and Rust ecosystem.

Kafka internals and the broker landscape — logs vs. queues, partitions, consumer groups, replication, and exactly-once semantics.

Measuring before guessing — profiling, benchmarking methodology, mechanical sympathy, and a shared vocabulary from CPU cache to p99.

Pushing data to clients — WebSockets, SSE, long polling, WebTransport, gRPC streaming, webhooks — and how to choose and scale them.

How machines agree — Raft, quorums, leader election, and what consensus does (and refuses to do) for the systems built on it.

The two guardrails of a public API — bounding request rates without unfairness, and making retries safe by design.

How full-text search works — inverted indexes, analysis, relevance scoring, and operating Elasticsearch-class systems next to your database.

Core concepts governing how programs execute multiple tasks simultaneously, and the trade-offs between competing approaches.

Practice material for the theme: multi-milestone build projects mapped onto its concept notes.