Fresher-friendly system design questions — scalability, APIs, and real-world trade-offs.
System design explains how components (clients, APIs, databases, caches, queues) work together at scale. Companies now ask simplified design for interns (URL shortener, chat app) to test structured thinking, not memorized diagrams. You clarify requirements, estimate scale, draw boxes, and discuss trade-offs.
Functional: features (post tweet, upload file). Non-functional: scale (1M DAU), latency (p99 < 300ms), availability, consistency needs. Always ask: read vs write ratio? Strong consistency required? Expected QPS? This mirrors real Indian product company onsite rounds.
Vertical: bigger machine (more CPU/RAM) — simpler but hits limits. Horizontal: more machines behind a load balancer — standard for web scale. Most designs scale out stateless app servers and shard data stores. Mention auto-scaling groups on AWS/GCP.
Distributes incoming traffic across healthy backend instances using algorithms (round-robin, least connections). Provides SSL termination and health checks. Layer 7 (HTTP) balancers can route by path/host.
Essential when single server cannot handle campus-app-level traffic spikes.
Caching stores frequently read data closer to the user (browser CDN, app Redis, DB query cache) to cut latency and DB load. Pattern: cache-aside — read cache first, on miss load DB and populate cache with TTL. Discuss invalidation on writes to avoid stale data.
Content Delivery Network: edge servers worldwide serve static assets (images, JS, video) from nearest POP. Reduces origin load and improves TTFB for users across India and abroad. Pair CDN with cache headers and versioned filenames.
SQL (PostgreSQL, MySQL): structured schema, ACID transactions, joins — orders, payments, accounts. NoSQL (MongoDB, DynamoDB): flexible schema, horizontal scale, high write throughput — feeds, logs, catalogs. Many systems use both (polyglot persistence).
Copy data from primary to replica(s). Read replicas offload SELECT traffic; async replication may lag. Failover promotes replica if primary dies.
Mention replication lag causing briefly stale reads — acceptable for many social feeds, not for wallet balances without careful design.
Splitting data across multiple DB nodes by shard key (user_id hash). Enables write scale beyond one machine. Challenges: cross-shard queries, rebalancing, hot shards. Interview answer: choose shard key with even distribution (avoid celebrity user hotspot).
In a network partition, you choose between Consistency (all nodes see same data) and Availability (every request gets a response). Partition tolerance is mandatory in distributed systems. CP: banking ledger. AP: social likes count with eventual consistency.
Async buffer (Kafka, RabbitMQ, SQS) between producers and consumers. Decouples services, smooths traffic spikes, enables retries. Example: after order placement, publish 'OrderCreated' — email, inventory, analytics consume independently.
Improves reliability vs synchronous chains.
Resource-oriented URLs (GET /users/123), proper HTTP verbs and status codes, pagination (?cursor=), idempotency keys for payments, versioning (/v1/). Stateless servers scale horizontally; auth via JWT/OAuth at gateway.
Requirements: shorten long URL, redirect, optional analytics. Write path: hash or base62 ID → store in DB (short → long). Read-heavy: cache hot links in Redis. Scale: stateless redirect servers, DB sharded by short code, CDN for static.
Discuss collision handling and custom aliases.
Limit requests per user/IP (token bucket or sliding window in Redis). Return 429 with Retry-After. Place at API gateway edge. Protects backend from abuse and fair usage in freemium products — common follow-up in backend interviews.
Single entry point handling auth, rate limiting, routing to microservices, request logging, and SSL. Examples: Kong, AWS API Gateway. Simplifies client apps and centralizes cross-cutting concerns instead of duplicating in every service.
Polling: client repeatedly asks — simple but wasteful. WebSockets: bidirectional real-time (chat, live quiz). SSE: server push one-way (live scores). Choose based on directionality and scale; WebSockets need connection management and sticky sessions or pub/sub backplane.
Distributes keys across nodes so adding/removing a node only remaps a fraction of keys — used in distributed caches and CDNs. Helps avoid full rehash when cluster size changes. Good vocabulary for cache layer design questions.
Sync: REST/gRPC between services — simple but tight coupling and cascading failures. Async: events via message broker — better decoupling. Mention circuit breakers, timeouts, retries with backoff, and idempotent consumers for reliability.
Golden signals: latency, traffic, errors, saturation (CPU/memory). SLOs like 99.9% availability and error budget. Fresher answer: monitor p95 latency, 5xx rate, queue depth, DB connections — tie to user experience during Flipkart/Amazon sale-like spikes.
