System Design Foundations and Interviews

Translate an open-ended system design prompt into prioritized functional requirements, security and privacy constraints, and an explicit scope.

Derive measurable non-functional requirements for latency, availability, durability, consistency, and cost.

Distinguish latency, throughput, and concurrency when analyzing a backend system.

Perform back-of-the-envelope estimates for request volume, peak traffic, storage, and bandwidth.

Trace a web request through DNS, TCP/TLS connection establishment, HTTP, application processing, and data storage.

Draw a single-server baseline architecture and identify its bottlenecks and single points of failure.

Use a time-boxed interview workflow to clarify requirements, estimate scale, sketch a baseline, and prioritize architectural refinements.

Choose between vertical and horizontal scaling for a stated workload and constraint set.

Distinguish Layer 4 from Layer 7 load balancing and select the appropriate level for a scenario.

Select a load-balancing algorithm and health-check strategy for a replicated service.

Convert a stateful application tier into a stateless tier by externalizing session state.

Distinguish the responsibilities of a reverse proxy, API gateway, and service discovery mechanism.

Choose autoscaling signals and explain how delayed or unstable signals can cause scaling failures.

Design a service tier that remains available during an instance or availability-zone failure.

Derive a data model from a system's entities, relationships, access patterns, and scale requirements.

Choose database indexes for a query pattern and explain their read, write, and storage costs.

Choose transaction boundaries and an isolation level that preserve a stated business invariant under concurrent requests.

Choose among relational, key-value, document, and wide-column databases for a stated workload.

Design a primary-replica topology for read scaling and failover, and explain how replica lag affects reads.

Choose a partition key and sharding strategy that avoids uneven load and cross-shard operations.

Apply consistent hashing to reduce data movement when storage nodes are added or removed.

Identify where caching can reduce latency or backend load in a request path.

Choose among cache-aside, read-through, write-through, and write-behind patterns for a workload.

Select cache keys, expiration policies, and eviction policies for a stated access pattern.

Design a cache invalidation strategy with an explicit staleness guarantee.

Mitigate cache stampedes and hot-key overload using appropriate protection techniques.

Determine when a content delivery network is appropriate and define what it should cache.

Decide whether an operation should execute synchronously or asynchronously.

Distinguish work queues, publish-subscribe systems, and event streams by their delivery needs.

Choose an at-most-once, at-least-once, or effectively-once processing strategy for a workflow.

Make a message consumer idempotent by defining idempotency keys and deduplication state.

Preserve or deliberately relax event ordering for a partitioned messaging workload.

Design bounded queueing, consumer concurrency, and backpressure behavior to keep an asynchronous pipeline stable under overload.

Design retry, exponential-backoff, and dead-letter handling for failed asynchronous work.

Use timeouts and circuit breakers to prevent cascading failures between services.

Apply the CAP theorem to reason about behavior during a network partition.

Choose a strong or eventual consistency model and an appropriate read-write quorum for a use case.

Select a distributed unique-ID strategy based on ordering, availability, and scale requirements.

Compare fixed-window, sliding-window, token-bucket, and leaky-bucket rate-limiting algorithms.

Perform a basic security review by identifying trust boundaries and selecting authentication, authorization, encryption, and abuse controls.

Define service-level indicators, objectives, and alerts for a user-facing service.

Use metrics, logs, and traces to localize a performance or reliability problem.

Create a recovery plan using redundancy, failover, backups, and explicit RTO and RPO targets.

Specify APIs and core data models that support a system's prioritized use cases.

Present an architecture clearly, justify its trade-offs, and evolve it when an interviewer changes a constraint.

Design a scalable URL-shortening service and defend its storage, caching, and identifier choices.

Design a distributed rate-limiting service and explain its behavior under concurrency and failure.

Design a multi-channel notification service with asynchronous delivery, retries, and user preferences.

Design a real-time chat service with connection management, message ordering, and offline delivery.

Design a social news-feed service with an explicit fan-out, ranking, caching, and consistency strategy.