Quick answers to the questions you'll face on every architecture review.
A growing reference library. The hard topics in system design distilled into short, scenario-driven explanations: load balancers, caching, consistency, queueing, cloud trade-offs, and the rest. Use it alongside the roadmap, or as a quick lookup before an interview.
Foundations
7 topicsTCP vs UDP
When each protocol actually fits.
HTTP/2 and HTTP/3
What changed and why it matters for your design.
REST, RPC, gRPC, GraphQL
Picking the right API style for the job.
Latency, throughput, bandwidth
What each really means and how they relate.
Synchronous vs asynchronous
When to break a call into async and what it costs.
DNS: how the internet finds anything
Resolution path, caching layers, TTL, propagation, and where it bites.
WebSockets vs Server-Sent Events vs long polling
Three ways to push data to a client, and which one you actually want.
Databases
14 topicsSQL vs NoSQL
How to actually choose, not by buzzword.
ACID vs BASE
What each set of guarantees actually means.
Normalization vs denormalization
When to break the rules on purpose.
B-tree vs LSM tree
Why your database picks one over the other.
Indexes that help, indexes that hurt
When to add, when to skip, how to read EXPLAIN.
Read replicas
What they fix, what they don't, replication lag.
Sharding strategies
Range, hash, directory, and the pain that follows.
Schema migrations with zero downtime
Expand and contract, dual writes, backfills.
OLTP vs OLAP
Why the same data is laid out differently in each.
Time-series databases
When you need one and what you give up.
Transactions and isolation levels
Read committed, repeatable read, serializable, snapshot: what each protects against.
Optimistic vs pessimistic locking
When to lock the row, when to bet that nobody else will, and how to detect the bet you lost.
Change Data Capture (CDC)
Stream every change out of your database without dual writes.
Materialized views
A view that's actually a table, refreshed on a schedule or by trigger.
Consistency & Distribution
8 topicsCAP theorem
What it actually says vs the simplified version.
Strong, eventual, causal consistency
What each model promises and where each breaks.
Consensus: Raft and Paxos in plain English
Why we need them and how leader-follower really works.
Leader election
When, how, and what happens during a partition.
Two-phase commit vs sagas
Picking the right pattern for cross-service transactions.
Idempotency
Why every retryable operation needs it.
Time, clocks, and ordering
NTP, logical clocks, vector clocks.
Quorum reads and writes (R + W > N)
Tunable consistency the Dynamo way: pick how strict you want to be, per query.
Caching
5 topicsWhy cache and what to cache
Picking the right things to cache.
Cache strategies
Aside, through, back, around. When each one fits.
Cache eviction
LRU, LFU, TTL, ARC and what each costs.
Cache invalidation
The hard part. Patterns that actually work.
CDN
When you actually need one and how it differs from your app cache.
Load Balancing
5 topicsLoad balancer: why, how, when
What problem a load balancer really solves.
L4 vs L7 load balancing
Network-layer vs application-layer trade-offs.
Load balancing algorithms
Round robin, least connections, consistent hash.
Sticky sessions
When you need them, what they cost.
API Gateway (vs load balancer vs reverse proxy)
What an API Gateway adds on top of a load balancer, and when you actually need one.
Messaging & Events
6 topicsWhy use a message queue
When async beats sync.
Kafka vs RabbitMQ vs SQS
What fits when.
At-most-once vs at-least-once vs exactly-once
What each actually guarantees in practice.
Pub/sub vs point-to-point queue
Fan-out vs work-distribution.
Event sourcing vs state-based persistence
When the event log is the source of truth.
Batch vs stream processing (Lambda vs Kappa)
Two ways to compute the same number, and the architecture that picks both.
Search & Indexing
2 topicsScaling
6 topicsHorizontal vs vertical scaling
Trade-offs and where each breaks down.
Stateless vs stateful services
Why stateless is easier to scale, and when you can't be.
Microservices vs monolith
When to split, when to stay.
Connection pooling
Why and how, plus the failure mode no one talks about.
Multi-region
Latency, write strategies, conflict resolution.
Hot, warm, cold storage tiers
What goes where, what each tier costs.
Reliability
7 topicsCircuit breaker
When it fires, when it doesn't, the half-open state.
Retry with exponential backoff and jitter
Why jitter matters more than backoff.
Bulkheads and rate limiting
Isolating failures, capping load.
Graceful degradation
Failing partially rather than failing whole.
Replication vs backup
They are not the same, and confusing them costs you data.
Disaster recovery: RTO vs RPO
What promises you can keep and what you can't.
Backpressure and flow control
What a slow consumer should do to a fast producer that doesn't take 'no' for an answer.
Security
5 topicsAuthentication vs authorization
Two different problems, often conflated.
JWT vs session cookies
When to pick which, what each costs.
Rate limiting strategies
Token bucket, leaky bucket, fixed window, sliding window.
API key vs OAuth vs mTLS
When each authentication style fits.
Secrets management
Vault, KMS, env vars, and what not to do.
Operational
7 topicsObservability: metrics, logs, traces
What each is for and how they fit together.
Health checks: liveness vs readiness vs startup
What each one really signals.
Pagination: offset vs cursor vs seek
Picking the right one for the data shape.
Service discovery: DNS vs registry vs sidecar
Trade-offs across the three approaches.
API versioning strategies
URL, header, content negotiation, gradual rollout.
SLI, SLO, SLA, and error budgets
The language reliability engineers use to argue about how broken is too broken.
Feature flags, canary, blue-green: the three deployment safety patterns
Ship the code without shipping the risk.
Cloud Comparisons
10 topicsCompute: EC2 vs Compute Engine vs Azure VM
Pricing models, instance families, network egress.
Object storage: S3 vs GCS vs Azure Blob
Consistency, durability, lifecycle, cost models.
Managed SQL: RDS vs Cloud SQL vs Azure SQL
Engine support, HA, backup, failover.
Serverless: Lambda vs Cloud Functions vs Azure Functions
Cold starts, limits, pricing.
Managed Kubernetes: EKS vs GKE vs AKS
Control plane, upgrade story, networking.
Managed messaging: SQS/SNS vs Pub/Sub vs Service Bus
Throughput, semantics, ordering.
Data warehouses: Redshift vs BigQuery vs Synapse
Storage model, pricing, concurrency.
CDN: CloudFront vs Cloud CDN vs Azure Front Door
PoP coverage, edge functions, pricing.
IAM: AWS IAM vs GCP IAM vs Azure AD
Permission models compared.
Observability: CloudWatch vs Cloud Monitoring vs Azure Monitor
What each catches and where they fall short.
No topics match these filters
Try a different search term or clear the filters.