Learn the fundamentals.

Core building blocks and mental models for approaching any system design problem. Covers components, trade-offs, and the structured thinking framework used throughout all practice problems.

How to identify, quantify, and reason about non-functional requirements in system design interviews. Covers availability, consistency, durability, latency targets, and SLA trade-offs.

Back-of-the-envelope calculations for storage, bandwidth, and compute in system design interviews. Covers QPS estimation, storage growth projections, and capacity planning techniques.

Principles and patterns for designing clean, consistent APIs in system design interviews. Covers RESTful conventions, endpoint design, pagination, versioning, and error handling.

How to apply domain-specific context to system design problems. Covers techniques for clarifying business requirements, identifying domain entities, and translating real-world constraints into technical decisions.

Understand microservice architecture decomposition, service boundaries, and when to choose microservices over monoliths for system design interviews.

Learn REST, gRPC, and request-response patterns for inter-service communication, including when synchronous calls are the right choice.

Master message queues, event-driven architectures, and pub/sub patterns for decoupled inter-service communication in distributed systems.

Understand how data moves across microservices including saga patterns, CQRS, and strategies for maintaining consistency without distributed transactions.

How caching layers reduce latency and load, covering cache placement strategies, invalidation patterns, and consistency trade-offs in distributed systems.

Splitting read and write paths to scale database throughput independently, covering replication topologies, consistency trade-offs, and read replica routing.

Scaling by adding more machines rather than bigger ones, covering stateless service design, load balancing strategies, and auto-scaling patterns.

Compare SQL, NoSQL, and specialized storage engines to make informed database selection decisions in system design interviews.

Understand ACID guarantees, isolation levels, distributed transactions, and optimistic concurrency control for designing consistent data operations.

Learn how data moves through distributed systems including ETL pipelines, change data capture, and data replication strategies.

Understand CAP theorem, consensus protocols, distributed clocks, and failure modes that underpin advanced system design reasoning.

Foundations of big data systems: when data volume, velocity, or variety exceeds single-machine capacity, and the architectural patterns that address each dimension.

Processing large bounded datasets in scheduled or triggered jobs, covering MapReduce, DAG-based workflows, and batch job orchestration patterns.

Processing unbounded event streams in real time or near-real time, covering windowing strategies, exactly-once semantics, and stateful stream operators.

Operating and monitoring data pipelines in production, covering scheduling, failure recovery, observability, and SLA management for batch and streaming jobs.

Combining batch and stream processing in Lambda and Kappa architectures, covering when to use each approach and how to manage the complexity of dual pipelines.

How full-text search works under the hood, covering inverted indexes, tokenization, relevance scoring, and search infrastructure scaling patterns.

Indexing and querying location-based data efficiently, covering geohashing, spatial indexes, proximity search, and tile-based map serving.

Architectures for storing, processing, and serving media at scale, covering upload pipelines, transcoding, CDN delivery, and adaptive bitrate streaming.

Space-efficient data structures that trade exactness for performance, covering Bloom filters, Count-Min Sketch, HyperLogLog, and their system design applications.

Building systems that deliver low-latency updates and analytical insights simultaneously, covering WebSockets, pub/sub fanout, time-series storage, and real-time dashboarding.

Cross-cutting design patterns that recur across system design problems, synthesizing strategies from all other learning areas into reusable interview templates.

Nalar Linuwih's guide to the behavioral round: the signals interviewers grade, how the scope bar scales with seniority, structuring answers with STAR, the question families to prepare, and how signals become a hire decision.

Deliver behavioral answers cleanly under pressure with STAR: spend most of your time on the Action, speak in the first person, show your judgment, and land a quantified result.

The hardest behavioral family: what the conflict question actually tests (empathy, judgment, resolution), how to steelman the other side, and why disagree-and-commit beats winning.

Turn the failure and feedback questions into your strongest signal: pick a real, owned mistake, attach a concrete lesson, and show you receive hard feedback and act on it.

The prep system that ties the track together: assemble 4-6 rich stories, map them to every signal area, write them in STAR, match scope to level, and practice out loud.

How senior and staff behavioral interviews are judged: driving outcomes through other people, aligning teams you don't manage, and telling stories about leverage rather than personal output.

The questions you ask are themselves a signal. What strong questions reveal, categories with concrete examples, how they scale with level, what to avoid, and reading the answers as your own signal about the job.