System Design

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

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

Estimate request rates from daily active users and usage assumptions.

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

Define a minimal API contract for a service from its 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.

Explain when wide-column storage fits high-volume, key-oriented access patterns.

Choose between relational and non-relational 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.

Design a stateless application tier that can scale horizontally.

Compare client-side sessions, server-side sessions, and token-based sessions.

Select autoscaling signals for a stated traffic pattern.

Design a fixed-window, sliding-window, or token-bucket rate limiter for a given requirement.

Make a retried API operation safe by using idempotency keys.

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.

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

Apply circuit breakers and bulkheads to contain cascading failures.

Choose a strategy for generating unique identifiers across multiple servers.

Evaluate when a distributed lock is necessary and what can go wrong with it.

Use a saga to coordinate a multi-service workflow without a global transaction.

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.

Design structured logs with request correlation identifiers.

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

Define an actionable alert tied to user-visible impact.

Distinguish authentication from authorization in a service architecture.

Protect service data using encryption, secrets management, and least-privilege access.

Choose backup frequency and disaster-recovery targets using RPO and RTO.

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.

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

Collect click analytics without slowing the redirect path.

Protect the service against malicious links, scraping, and abusive traffic.

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.

Implement cursor-based pagination for a changing feed.

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.