Start Here
StaffSignal playbooks build the judgment that separates L5 answers from Staff answers. Each playbook is a complete preparation unit — not a problem catalog. Pick one and study it until you can defend the tradeoffs, failure modes, and ownership boundaries.
The Core 5
FreeIf you only have time for five playbooks, start here. These cover the most common Staff interview surface area and build transferable judgment.
12345
Rate Limiting
Appears in almost every system design. Forces you to reason about distributed state, consistency tradeoffs, and graceful degradation — the three pillars of Staff-level answers.
Distributed Caching
If you can't explain when caching is premature, who owns correctness when cache and DB diverge, and what happens during a thundering herd — you're not ready for a Staff design round.
Message Queues
Every async system design exposes your understanding of delivery guarantees and failure handling. If you're still saying 'exactly once delivery' in interviews, this playbook will fix that.
Circuit Breakers
Cascading failures are the #1 way production systems die. If you can't articulate failure domain isolation, retry budgets, and when to fail open vs closed — you'll miss the resilience dimension of every Staff answer.
Service Discovery
Every microservice question assumes you understand how services find each other. Registry reliability, health check layering, and naming governance separate L5 hand-waving from Staff-level ownership.
Together, these force you to reason about distributed state, failure modes, and ownership tradeoffs — the three dimensions interviewers probe at L6+.
By System Type
ProDifferent interviews stress different system properties. If you know the type of system you'll be asked about, these tracks focus your preparation.
Latency-sensitive
User-facing systems where P99 matters
Data-heavy
Analytical and storage-intensive systems
Correctness-critical
Systems where wrong > slow
Frameworks & Patterns
Cross-cutting decision frameworks that apply to multiple playbooks. Master these patterns and you'll recognize them in any system design question.
Scaling Reads
Read replicas, caching layers, CDN, and CQRS. Every read optimization is a consistency debt.
Scaling Writes
Sharding, partitioning, write-behind, and event sourcing. Write scaling is a schema commitment.
Dealing with Contention
Pessimistic vs optimistic locking, queues, reservations, and CAS operations. Contention avoidance beats contention resolution.
Real-time Updates
WebSockets vs SSE vs polling and fan-out strategies. Every persistent connection is operational state.
Data Pipeline Patterns
Batch vs stream, backfill strategies, schema evolution, and exactly-once delivery. Pipeline reliability is measured by the backfill you never had to run.
Degraded Mode Framework
Fail-open vs fail-closed decisions, fallback strategies, and ownership during dependency failures.
Distributed Coordination Framework
Local-first vs centralized state, leasing, routing, and reconciliation patterns for distributed systems.
Build vs Buy Framework
TCO analysis, operational burden assessment, and when to use managed services vs custom solutions.
Handling Large Blobs
Chunked upload, presigned URLs, async processing, and CDN delivery. Upload reliability is a client-side problem.
Managing Long-Running Processes
Sagas, state machines, compensation, and idempotency. Every long-running process needs a cancel button.
Foundations & Study Guides
Progressive study guides that teach the mechanics every playbook builds on. Each foundation covers concepts from first principles through Staff-level interview scenarios.
Network Latency & Protocols
Every millisecond of RTT is a design decision you can't optimize away later. Latency budgets, connection lifecycle costs, protocol selection (HTTP/2 vs gRPC vs WebSocket), and how tail-latency amplification turns a 5-service call chain into a p99 nightmare.
Caching Fundamentals
Cache is consistency debt — every cached value is a promise that staleness is acceptable. Cache-aside, write-through, write-behind tradeoffs, thundering herd prevention, and how Facebook TAO, Netflix EVCache, and Discord's L1 cache handle billions of reads/second.
Consistent Hashing
Add a node, move 1/N of the data — not all of it. Ring mechanics, virtual nodes for uniform distribution, and how DynamoDB, Cassandra, and Discord implement it differently. Plus: when jump hash or rendezvous hash is actually the better choice.
Back-of-Envelope Estimation
"How many servers do we need?" — answered in 90 seconds. The 20 numbers every Staff engineer has memorized (1MB/s per Postgres connection, 100K ops/s per Redis node, 10ms SSD read), plus the estimation framework to chain them into capacity decisions on a whiteboard.
API Design Patterns
REST at the boundary, gRPC internally, GraphQL only when clients genuinely vary. Cursor pagination (not offset), idempotency keys as a requirement not a feature, and how Stripe's API versioning maintains backward compatibility across 10+ years of changes.
Database Indexing
The wrong index is worse than no index — it costs writes and the planner ignores it anyway. B-tree vs LSM-tree tradeoffs, composite index column ordering (leftmost prefix matters), covering indexes for index-only scans, and why Postgres, Cassandra, and RocksDB index differently.
Sharding & Partitioning
Your shard key is a multi-year commitment — choose wrong and no amount of hardware fixes it. Hash vs range vs compound keys, re-sharding without downtime, cross-shard query costs, and how Instagram, Vitess, and Notion partition billions of rows.
Consistency Models & Partition Behavior
"Eventual consistency" is not a single thing — it's a spectrum, and the right point on it is a business decision. Strong, causal, read-your-writes, monotonic, eventual — with per-operation tuning. How Google Spanner achieves global strong consistency, why DynamoDB defaults to eventual, and how LinkedIn tunes consistency per-operation in production.
Data Modeling & Schema Design
Model for the query, not the entity — if you design tables before knowing your access patterns, you've already failed. Normalization vs denormalization as a write-amplification budget, embed vs reference tradeoffs, and how Uber, Airbnb, and Twitter evolved schemas under 10x growth.
Key Technologies
Deep dives into the technologies that power system design answers. Architecture, internals, failure modes, and interview-specific application.
Databases
Redis
In-memory data store for caching, pub/sub, and leaderboards
PostgreSQL
ACID transactions, MVCC, and the default relational database
Elasticsearch
Full-text search, log aggregation, and relevance ranking
Cassandra
Wide-column NoSQL for massive write throughput and multi-DC
DynamoDB
AWS managed NoSQL with single-table design and auto-scaling
Time Series DBs
Prometheus, InfluxDB, TimescaleDB for metrics and telemetry
How to use StaffSignal
- 1.Pick one playbook from the sidebar. Read it end-to-end — every section reinforces the others.
- 2.Do the drills at the end. They're not optional — the drills are where calibration happens.
- 3.Before your interview, scan the relevant foundation card. Then re-read the playbook's executive summary.
Most candidates study 3–5 playbooks deeply. That's enough.