23 articles in high level design › trade-offs.
Learn when SQL's ACID guarantees are non-negotiable and when NoSQL's horizontal scale is the only viable path — with exact dimensions to defend your database choice in every interview.
Learn exactly when to split a monolith into microservices, what the real costs are (hint: it's not lines of code), and how to make that call without destroying your team.
Learn when synchronous request-response is the right tool and when async queues unlock scale that blocking calls can never achieve, with the math to defend each choice.
Learn when REST's HTTP caching wins over GraphQL, when GraphQL's typed queries earn their complexity cost, and how to defend either API choice in a system design interview.
When to use WebSocket, SSE, long polling, and webhooks, and the backpressure and fan-out traps that kill push systems quietly at scale.
The tradeoff between data freshness guarantees: when you need every read to see the latest write, when stale reads are acceptable, and the techniques that let you choose per operation.
The real tradeoff at the heart of the CAP theorem, what it means to choose availability over consistency during a partition, which real systems sit where on this spectrum, and how PACELC extends the picture.
How to design databases and caches for either read-heavy or write-heavy workloads, covering denormalization, read replicas, write-ahead logs, CQRS, and the tradeoffs of optimizing for one at the expense of the other.
When to normalize your database schema for integrity and storage efficiency vs. when to denormalize for query performance, the practical decision criteria, and the cost of getting it wrong.
The difference between scaling up (bigger machines) and scaling out (more machines): when each strategy applies, the limits of vertical scaling, and why horizontal scaling requires stateless architecture.
The difference between latency (response time for a single request) and throughput (requests per second capacity), why optimizing for one often hurts the other, and how to balance them for your workload.
The architectural difference between stateful and stateless services: what state means, why stateless services are easier to scale, and the patterns for managing state outside the service when it's necessary.
When to process data in large batches vs. a continuous stream, covering latency requirements, state management, fault tolerance, and the tradeoffs between Lambda and stream-only approaches.
The tradeoff between serving data fast from a cache vs. serving data that reflects the latest state, covering TTL strategies, cache invalidation patterns, and how to decide which data can be cached and for how long.
When to add a read replica vs. a cache: the access pattern that drives the choice, write-heavy invalidation problems, replica lag trade-offs, and why adding a cache to a write-heavy system doesn't help.
The architectural difference between synchronous RPC calls (gRPC, REST) and asynchronous messaging (Kafka, SQS): when each model fits, the failure modes, and why the choice affects your entire service topology.
When to choose TCP vs UDP: reliability trade-offs, when UDP wins in gaming, video, and DNS, what QUIC does differently, and how to add reliability at the application layer when UDP is the right choice.
How to choose between polling, webhooks, Server-Sent Events, and WebSockets: latency, infrastructure complexity, directionality, scalability, and which pattern fits each use case.
When to choose Kafka vs. RabbitMQ: log-based vs. traditional broker, message replay, ordering guarantees, fan-out patterns, retention, and which architecture fits each messaging pattern.
When Redis is the right cache and when Memcached still wins: data structure richness, persistence, replication, clustering, memory efficiency, and the operational differences that matter at scale.
When to use block storage, file storage, or object storage: performance characteristics, consistency models, cost, use cases for each, and how cloud services map to these types.
How PostgreSQL, MySQL, and SQL Server compare for system design, covering feature depth, replication models, JSON support, full-text search, cloud-managed options, and when each is the right default.
When to use event-driven choreography versus a central orchestrator for multi-service workflows, covering tradeoffs in observability, coupling, error handling, and operational complexity.