System Design

Ask scope-defining questions that resolve ambiguity in a system-design prompt.

Separate a design prompt into functional requirements and non-functional requirements.

Estimate request rates from daily active users and usage assumptions.

Estimate storage and network capacity from record sizes and traffic assumptions.

Define a minimal HTTP API contract from a service's functional requirements.

Derive core data entities and access patterns from a service description.

Draw a high-level architecture showing clients, services, data stores, and data flows.

Present a design in a structured interview sequence while tracking unresolved risks.

Create a relational schema with primary keys, foreign keys, and integrity constraints.

Explain how a database index changes read performance, write cost, and storage usage.

Identify when a multi-step operation requires a database transaction.

Explain the ACID properties using a concrete transaction.

Model simple access patterns in a key-value store.

Model nested or evolving records in a document database.

Distinguish wide-column databases from object storage and identify suitable access patterns for each.

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

Explain how leader-follower replication supports read scaling and redundancy.

Compare synchronous and asynchronous replication trade-offs.

Describe how replica lag can affect user-visible behavior.

Choose a sharding key for a stated access pattern.

Identify hot partitions and uneven data distribution in a sharding plan.

Explain how consistent hashing reduces data movement when nodes change.

Contrast strong, eventual, and read-your-writes consistency.

Apply the CAP trade-off to a service experiencing a network partition.

Explain how caching reduces latency and backend load.

Apply the cache-aside pattern to a read-heavy service.

Compare write-through, write-around, and write-back caching.

Choose cache keys, time-to-live values, and eviction policies for a workload.

Identify stale-data risks and select an appropriate cache-invalidation strategy.

Mitigate cache stampedes and hot-key problems.

Explain how a content delivery network serves static and cacheable content.

Design a multi-layer caching strategy across clients, edge servers, and application services.

Distinguish the roles of a reverse proxy, load balancer, and API gateway.

Compare round-robin, least-connections, and consistent-hashing load balancing.

Explain how health checks keep traffic away from unhealthy instances.

Compare client-stored, server-stored, and token-based approaches to managing session state.

Design a stateless application tier that can scale horizontally.

Select autoscaling signals for a stated traffic pattern.

Compare the mechanics, accuracy, and memory trade-offs of fixed-window, sliding-window, and token-bucket rate limiting.

Design a centralized rate-limiting component for an API gateway using a chosen algorithm and key-value store.

Distinguish message queues, publish-subscribe systems, and event streams.

Design a producer-worker flow for an operation that should run asynchronously.

Compare at-most-once, at-least-once, and effectively-once processing semantics.

Design an idempotent message consumer that tolerates duplicate delivery.

Configure bounded retries with exponential backoff and jitter.

Use a dead-letter queue to isolate repeatedly failing messages.

Preserve per-entity ordering in a partitioned messaging system.

Recognize backpressure and choose a strategy to keep producers from overwhelming consumers.

Identify partial failures and choose suitable timeout boundaries between services.

Make a retried API operation safe by using idempotency keys.

Explain how retry storms arise and how retry budgets reduce them.

Apply the circuit breaker pattern to detect downstream service failures and fail fast.

Apply the bulkhead pattern to isolate resource pools and prevent failure propagation across dependencies.

Choose an available, collision-resistant identifier-generation strategy for a multi-server service.

Design redundancy and failover for a service with an availability target.

Select graceful-degradation behavior when a non-critical dependency fails.

Distinguish service-level indicators, objectives, and agreements.

Choose useful metrics for traffic, latency, errors, and resource saturation.

Explain how request correlation identifiers connect logs across service boundaries.

Trace a request across multiple services to locate a latency bottleneck.

Define an actionable alert tied to user-visible impact.

Distinguish authentication from authorization and place each control in a service architecture.

Explain how encryption at rest and secure secrets management protect sensitive backend data.

Clarify the functional and scale requirements of a URL-shortening service.

Estimate traffic, storage, and identifier-space requirements for a URL shortener.

Define the URL-shortening APIs and persistent data model.

Compare random, counter-based, and hash-based short-code generation by collision risk, predictability, and coordination cost.

Design a low-latency redirect path using caching and database access.

Collect click analytics without slowing the redirect path.

Design asynchronous malicious-link screening for newly submitted URLs.

Present and defend an end-to-end URL-shortener design within 45 minutes.

Clarify product behavior, freshness, and scale requirements for a news feed.

Define APIs and data models for users, follows, posts, and feed entries.

Compare fan-out-on-write with fan-out-on-read.

Design a hybrid fan-out strategy for ordinary and high-follower accounts.

Design cursor-based pagination for a changing feed and explain its advantage over offset pagination.

Choose caches for posts, timelines, and user metadata.

Handle duplicate, delayed, or missing feed updates caused by asynchronous processing.

Present and defend an end-to-end news-feed design within 45 minutes.

Clarify delivery, history, presence, and scale requirements for a chat service.

Compare WebSockets, server-sent events, and polling for real-time communication.

Define APIs and data models for conversations, membership, and messages.

Route persistent client connections across multiple chat servers.

Design presence and last-seen tracking with appropriate consistency.

Preserve message order within a conversation while tolerating retries.

Deliver messages to offline users and synchronize their history after reconnection.

Conduct and self-evaluate a 45-minute system-design interview using a requirements, estimation, architecture, bottleneck, and trade-off rubric.