Question 1

How would you design a URL shortener like bit.ly?

Accepted Answer

Generate a unique 6-7 character hash for each long URL, store the mapping in a database with a cache layer, and use a redirect (301/302) when users hit the short URL.

Question 2

What is the CAP theorem? How does it affect database choice?

Accepted Answer

CAP states a distributed system can only guarantee two of three: Consistency (all nodes see same data), Availability (every request gets a response), Partition Tolerance (system works despite network splits). Since partitions are unavoidable, real systems choose CP or AP.

Question 3

Explain horizontal vs vertical scaling. When would you choose each?

Accepted Answer

Vertical scaling adds more resources to one machine (CPU, RAM). Horizontal scaling adds more machines. Horizontal scales infinitely but adds distributed system complexity.

Question 4

What is consistent hashing and why is it used in distributed systems?

Accepted Answer

Consistent hashing maps both data keys and server nodes to the same hash ring. When nodes are added/removed, only K/N keys need to be remapped (vs K keys with standard modulo hashing), minimizing cache invalidation.

Question 5

What is the difference between SQL and NoSQL databases? When would you choose each?

Accepted Answer

SQL databases use structured schemas with ACID transactions and relational joins. NoSQL sacrifices some structure for horizontal scalability, flexible schemas, and specific data models (document, key-value, columnar, graph).

Question 6

What load balancing algorithms exist, and how do you choose between them?

Accepted Answer

A load balancer distributes incoming requests across multiple backend servers. Common ALGORITHMS are Round Robin (cycle through servers), Least Connections (send to the server with fewest active requests), Weighted variants (account for server capacity), and IP/URL Hash (route the SAME client/resource to the SAME server consistently). The choice depends on whether your servers are STATELESS or hold STATE, whether requests have wildly DIFFERENT costs, and whether you operate at LAYER 4 (TCP/raw connections) or LAYER 7 (HTTP-aware, can route by path/header).

Question 7

What are the main caching strategies (cache-aside, write-through, write-behind) and eviction policies?

Accepted Answer

Caching strategies define HOW data flows between your application, the cache, and the database. "Cache-aside" (lazy loading): app checks cache first, on miss reads from DB and POPULATES the cache. "Write-through": writes go to the cache AND database SYNCHRONOUSLY. "Write-behind" (write-back): writes go to the cache IMMEDIATELY and are FLUSHED to the database ASYNCHRONOUSLY later. Eviction policies (LRU, LFU, TTL) decide what gets REMOVED when the cache is full.

Question 8

How does database sharding work? What are the challenges of choosing a shard key?

Accepted Answer

Sharding (horizontal partitioning) splits a SINGLE logical database into MULTIPLE physical databases ("shards"), each holding a SUBSET of the data, based on a "shard key" (e.g., "user_id"). This allows a database to scale BEYOND what a single machine can handle. The hard part is CHOOSING the shard key — a poor choice causes "HOT SHARDS" (uneven load) or makes CROSS-SHARD QUERIES (joins, transactions across shards) slow or impossible without application-level orchestration.

Question 9

Explain database replication: master-slave vs master-master, and synchronous vs asynchronous replication.

Accepted Answer

Replication keeps COPIES of a database on multiple servers for REDUNDANCY (failover) and SCALABILITY (spreading reads). "Master-slave" (primary-replica): ONE server accepts WRITES, replicas serve READS and stay in sync via replication. "Master-master": MULTIPLE servers accept writes, requiring CONFLICT RESOLUTION. "Synchronous" replication waits for replicas to confirm a write before acknowledging it (zero data loss, higher latency); "asynchronous" acknowledges immediately and replicates in the background (lower latency, possible data loss on failover).

Question 10

Compare message queue systems: Kafka vs RabbitMQ vs SQS. When would you use each?

Accepted Answer

Message queues DECOUPLE producers and consumers, enabling asynchronous processing, buffering traffic spikes, and reliable delivery. RabbitMQ is a TRADITIONAL message BROKER — flexible routing (exchanges/queues), good for TASK QUEUES with COMPLEX routing logic. Kafka is a DISTRIBUTED LOG — built for HIGH-THROUGHPUT EVENT STREAMING, retains messages for REPLAY, and supports MULTIPLE independent consumers reading the same stream. SQS is AWS's managed, SIMPLE queue — minimal operational overhead, good default for STRAIGHTFORWARD task queues in an AWS-centric stack.

Question 11

What rate limiting algorithms exist (token bucket, leaky bucket, sliding window)? How would you implement a distributed rate limiter?

Accepted Answer

Rate limiting protects a service from being overwhelmed by capping how many requests a client can make in a time window. "Token bucket" allows BURSTS up to a bucket size while refilling tokens at a steady rate. "Leaky bucket" smooths bursts into a CONSTANT output rate (like a queue with a fixed drain speed). "Fixed window" counters are simple but allow DOUBLE the limit at window boundaries; "sliding window" (log or counter) fixes this by considering a ROLLING time range. For DISTRIBUTED systems, the counter state must live in a SHARED store (Redis) with ATOMIC increment-and-check operations to avoid race conditions across multiple servers.

Question 12

How does a CDN (Content Delivery Network) work, and what should and should not be cached on it?

Accepted Answer

A CDN is a network of geographically distributed SERVERS ("edge nodes" or "points of presence") that cache and serve content CLOSE to the end user, reducing latency and offloading traffic from the ORIGIN server. Static assets (images, CSS, JS bundles, videos) are IDEAL for CDN caching — they rarely change and are IDENTICAL for all users. Personalized or frequently-changing content (a user's dashboard, real-time prices) should NOT be cached at the CDN (or only cached very briefly / per-user with careful "Vary" headers).

Question 13

Compare microservices and monolithic architecture. When should a team migrate from monolith to microservices?

Accepted Answer

A MONOLITH is a SINGLE deployable application containing all functionality (one codebase, one database, one deploy). MICROSERVICES split functionality into INDEPENDENT services, each with its OWN codebase, deployment, and often its OWN database, communicating over a NETWORK (HTTP/gRPC/message queues). Monoliths are SIMPLER to develop, test, and deploy initially. Microservices enable INDEPENDENT SCALING and DEPLOYMENT of different parts, and let DIFFERENT TEAMS own different services — but introduce NETWORK LATENCY, DISTRIBUTED TRANSACTIONS, and significant OPERATIONAL complexity. The common advice: "start with a monolith" and split out services ONLY when there's a CONCRETE pain point (a specific component needs independent scaling, or a team is blocked by another team's deploy cadence).

Question 14

How would you design the backend architecture for a real-time chat application like WhatsApp or Slack?

Accepted Answer

A chat system needs: PERSISTENT CONNECTIONS (WebSockets) for real-time message delivery, a way to ROUTE a message to the recipient's connection (which might be on a DIFFERENT server), PERSISTENCE for message history (so messages survive disconnects/reloads), and PRESENCE tracking (online/offline/typing status). The key architectural challenge is that WebSocket connections are STATEFUL and tied to a SPECIFIC server — so when User A (connected to Server 1) sends a message to User B (connected to Server 2), Server 1 needs a way to get that message to Server 2. A PUB/SUB system (Redis Pub/Sub or Kafka) connecting all chat servers solves this.

Question 15

How would you design a news feed system (like Facebook or Twitter/X)? Explain the fan-out-on-write vs fan-out-on-read trade-off.

Accepted Answer

A news feed shows each user a CHRONOLOGICAL (or ranked) list of posts from people/things they follow. The core architectural decision is HOW to assemble each user's feed: "fan-out-on-write" (push) PRE-COMPUTES each follower's feed at POST TIME — when User X posts, the post is immediately inserted into the feed of EACH of X's followers. "Fan-out-on-read" (pull) computes the feed AT REQUEST TIME — when User Y opens their feed, the system queries posts from everyone Y follows and merges them. Push is FAST to read but EXPENSIVE for users with millions of followers ("celebrity problem"); pull is cheap to write but SLOW to read for users following many people. Most large systems use a HYBRID.

Question 16

What is the Circuit Breaker pattern? How does it help microservices handle failures gracefully?

Accepted Answer

A Circuit Breaker wraps calls to a (potentially failing) downstream service and TRACKS failure rates. When failures exceed a threshold, the circuit "OPENS" — further calls FAIL IMMEDIATELY (without even attempting the network call) for a cooldown period, giving the failing service time to RECOVER and preventing the CALLER from wasting resources on calls likely to fail. After the cooldown, the circuit goes "HALF-OPEN" — it allows a FEW test requests through; if they succeed, the circuit "CLOSES" (normal operation resumes), if they fail, it goes back to OPEN. This prevents CASCADING FAILURES, where one slow/failing service causes its CALLERS to also become slow/exhausted (e.g., from accumulating timed-out requests and exhausted connection pools).

Question 17

What does idempotency mean in distributed systems, and how do you design idempotent APIs?

Accepted Answer

An operation is IDEMPOTENT if performing it MULTIPLE TIMES has the SAME EFFECT as performing it ONCE. This matters in distributed systems because NETWORK FAILURES are common, and the STANDARD response to "did my request succeed?" uncertainty (timeout, dropped connection) is to RETRY — but if the original request actually DID succeed (the response was just lost), a naive retry could DUPLICATE the effect (e.g., charging a customer TWICE, creating TWO orders). Idempotent APIs are designed so RETRIES are SAFE — typically via an "idempotency key" that the server uses to RECOGNIZE and DEDUPLICATE repeated requests.

Question 18

How would you design a globally unique ID generator for a distributed system (like Twitter's Snowflake)?

Accepted Answer

In a SHARDED/distributed system (recall [[sd-8]]), a simple auto-incrementing database ID doesn't work — multiple shards/servers would generate COLLIDING IDs. A distributed ID generator must produce IDs that are UNIQUE across all nodes WITHOUT requiring coordination (a central counter would be a bottleneck and single point of failure). "Snowflake"-style IDs solve this by encoding a TIMESTAMP, a MACHINE/WORKER ID, and a per-millisecond SEQUENCE NUMBER into a single 64-bit integer — each component contributes to uniqueness, and the ID is also ROUGHLY SORTABLE BY TIME (useful for pagination and indexing).

Question 19

How would you design a search autocomplete / typeahead system (like Google Search suggestions)?

Accepted Answer

An autocomplete system must return TOP-K suggestions for a partial query PREFIX in under ~50-100ms, at MASSIVE query volume. The core data structure is a TRIE (prefix tree) where each node represents a character, and frequently-searched COMPLETE terms are stored with their POPULARITY/FREQUENCY at the corresponding node — traversing to a prefix and returning the TOP-K most popular completions below that node gives fast suggestions. At scale, the trie is too large/slow to rebuild on every new search, so it's built OFFLINE (periodically, from aggregated search logs) and served from an IN-MEMORY, possibly SHARDED, READ-ONLY data structure.

Question 20

How do database indexes work, and how do you decide what to index?

Accepted Answer

A database index is a SEPARATE data structure (typically a B-TREE, sometimes a HASH index) that maps COLUMN VALUES to the ROW LOCATIONS containing them — allowing the database to find matching rows WITHOUT scanning the entire table ("full table scan"). Indexes dramatically speed up READS (especially "WHERE column = X", "ORDER BY column", and JOIN conditions) but ADD OVERHEAD to WRITES (every INSERT/UPDATE/DELETE must also update each affected index) and consume EXTRA STORAGE. The decision of what to index balances these — index columns used in WHERE/JOIN/ORDER BY clauses of FREQUENT, PERFORMANCE-SENSITIVE queries, but avoid over-indexing tables with HEAVY write loads.

Question 21

What are database transaction isolation levels? Explain dirty reads, non-repeatable reads, and phantom reads.

Accepted Answer

Isolation levels control how much CONCURRENT transactions can "see" of each other's UNCOMMITTED or IN-PROGRESS changes — a trade-off between CONSISTENCY and PERFORMANCE/CONCURRENCY. From WEAKEST to STRONGEST: "Read Uncommitted" (can see uncommitted changes from other transactions — "dirty reads"), "Read Committed" (only sees COMMITTED data, but a value can CHANGE between two reads in the same transaction — "non-repeatable reads"), "Repeatable Read" (the SAME row always reads the same value within a transaction, but NEW rows matching a query can appear — "phantom reads"), and "Serializable" (transactions behave AS IF executed one-at-a-time, sequentially — strongest guarantee, most restrictive).

Question 22

How do distributed locks work? What problems can arise with naive implementations using Redis?

Accepted Answer

A distributed lock ensures only ONE process (across MULTIPLE servers) can perform a CRITICAL SECTION of work at a time — e.g., "only one worker should process this scheduled job" or "only one instance should run this migration". A naive Redis implementation uses "SET key value NX EX ttl" (set if not exists, with expiry) — but this has SUBTLE FAILURE MODES: if the holder takes LONGER than the TTL, the lock EXPIRES while they're still working, and ANOTHER process acquires it — now TWO processes think they hold the lock ("split brain"). Robust implementations use a UNIQUE TOKEN per lock attempt (to safely release ONLY your own lock) and either EXTEND the TTL (heartbeat/lease renewal) or design the protected operation to be SAFE even under this edge case (idempotency, fencing tokens).

Question 23

How would you design a distributed key-value store (like a simplified DynamoDB or Redis Cluster)?

Accepted Answer

A distributed key-value store provides a simple "GET key" / "PUT key value" interface while DATA is spread across MULTIPLE nodes for SCALE and REDUNDANCY. Core design pieces: PARTITIONING (consistent hashing — recall [[sd-4]] — to decide WHICH node(s) hold a given key), REPLICATION (each key is stored on N nodes for fault tolerance), and CONSISTENCY model (how many replicas must ACK a write/read — "quorum" reads/writes — trading consistency for availability per the CAP theorem, recall [[sd-2]]). Conflict resolution (when replicas diverge) uses techniques like "last write wins" (timestamps) or vector clocks.

Question 24

How would you design the backend for a video streaming platform like YouTube or Netflix?

Accepted Answer

A video platform has TWO very different workloads: VIDEO UPLOAD/PROCESSING (infrequent, heavy, asynchronous — TRANSCODING a video into multiple resolutions/formats) and VIDEO PLAYBACK (extremely frequent, latency-sensitive, served via a CDN). Uploaded videos are stored in OBJECT STORAGE (S3) and processed by a TRANSCODING PIPELINE that produces multiple QUALITY VARIANTS (480p, 720p, 1080p, 4K) using ADAPTIVE BITRATE formats (HLS/DASH — videos split into small CHUNKS at each quality level). Playback requests are served from a CDN, with the PLAYER dynamically switching quality based on the viewer's network speed.

Question 25

How would you design a web crawler that can index billions of pages?

Accepted Answer

A web crawler starts from SEED URLs, downloads each page, EXTRACTS new links from it, and adds those to a QUEUE of URLs to visit — repeating indefinitely. At billions-of-pages scale, the key challenges are: AVOIDING DUPLICATE crawls (a "seen URLs" set, often a BLOOM FILTER for memory efficiency), POLITENESS (not overwhelming any single website — rate-limiting PER DOMAIN, respecting "robots.txt"), PRIORITIZATION (crawl IMPORTANT/frequently-changing pages more often — e.g., news sites vs static pages), and DISTRIBUTING the work across MANY crawler machines while avoiding both DUPLICATE work and gaps in coverage.

Question 26

How would you design a distributed file storage system like Dropbox or Google Drive?

Accepted Answer

A file storage system has THREE main pieces: CHUNKING (large files are split into smaller fixed-size blocks, e.g., 4MB, so only CHANGED chunks need re-uploading on edits, and chunks can be uploaded/downloaded in PARALLEL), BLOCK STORAGE (the chunks themselves live in OBJECT STORAGE like S3, deduplicated by content hash), and a METADATA SERVICE (a database mapping "file → list of chunk hashes, in order, plus version history, sharing permissions, folder structure"). SYNC CLIENTS detect local file changes, diff against the last-known chunk list, and upload only the CHANGED chunks — enabling efficient incremental sync and version history.

Question 27

How would you design a payment processing system that handles money safely?

Accepted Answer

Payment systems must be CORRECT above all else — money can never be "lost" or "duplicated" due to a bug, retry, or crash. The core technique is DOUBLE-ENTRY LEDGER ACCOUNTING: every transaction creates TWO (or more) balanced entries (a DEBIT from one account and a CREDIT to another, summing to ZERO) — this makes the SYSTEM'S TOTAL BALANCE always verifiable and makes "where did the money go" always ANSWERABLE by querying the ledger. Combined with IDEMPOTENCY KEYS (recall [[sd-17]]) to safely handle retries, and ASYNC RECONCILIATION jobs that compare internal records against the PAYMENT PROCESSOR's (Stripe/PayPal) records to catch discrepancies.

Question 28

How would you design the backend for a ride-sharing app like Uber, focusing on driver-rider matching?

Accepted Answer

The core challenge is GEOSPATIAL: given a rider's location, find NEARBY available drivers EFFICIENTLY among potentially MILLIONS of drivers, with each driver's location updating EVERY FEW SECONDS. The standard solution is GEOHASHING (or a QUADTREE/S2 cells) — encoding latitude/longitude into a STRING/cell ID where NEARBY locations share PREFIXES — drivers are indexed by their geohash, and "find nearby drivers" becomes a fast PREFIX/RANGE query instead of scanning every driver's coordinates. Driver location updates are HIGH FREQUENCY and write-heavy, so they're stored in an IN-MEMORY store (Redis with geospatial commands) rather than a traditional database. Matching itself runs as a real-time process: candidate drivers are found via geo-query, filtered (availability, vehicle type), ranked (ETA, driver rating), and one is OFFERED the ride (with a timeout to accept).

Question 29

How would you design a notification system that sends push, email, and SMS at scale?

Accepted Answer

A notification system DECOUPLES "something happened that should notify a user" from "actually delivering that notification" via a QUEUE (recall [[sd-10]]) — application services publish NOTIFICATION EVENTS (not knowing/caring HOW they'll be delivered), and NOTIFICATION WORKERS consume these events, check the user's PREFERENCES (which channels they want — push/email/SMS, and for which event types), apply RATE LIMITING/BATCHING (don't send 50 separate emails for 50 likes in a minute — batch into a digest), and dispatch to the appropriate THIRD-PARTY PROVIDER (FCM/APNs for push, SES/SendGrid for email, Twilio for SMS) — with RETRY logic for failed deliveries and TEMPLATING for consistent message formatting.

Question 30

What is leader election and how do consensus algorithms like Raft work at a high level?

Accepted Answer

In a DISTRIBUTED system with multiple nodes, certain operations need to be performed by exactly ONE designated "LEADER" at a time (e.g., "which node accepts writes for this shard"). LEADER ELECTION is the process by which nodes AGREE on who that leader is, and detect/replace a FAILED leader. RAFT is a consensus algorithm that achieves this: nodes are in one of three states (FOLLOWER, CANDIDATE, LEADER); if followers don't hear from a leader within a TIMEOUT, one becomes a CANDIDATE and requests VOTES from peers; a candidate becomes LEADER if it gets votes from a MAJORITY — this majority requirement ensures only ONE leader can exist at a time even if the network PARTITIONS.

Question 31

What is an API Gateway and what responsibilities does it handle in a microservices architecture?

Accepted Answer

An API Gateway is the SINGLE ENTRY POINT for all client requests into a microservices system — instead of clients calling DOZENS of individual services directly, they call ONE gateway, which then ROUTES the request to the appropriate backend service(s). Beyond routing, the gateway centralizes CROSS-CUTTING CONCERNS that would otherwise be DUPLICATED in every service: AUTHENTICATION/AUTHORIZATION, RATE LIMITING (recall [[sd-11]]), REQUEST/RESPONSE TRANSFORMATION, LOGGING/MONITORING, and sometimes AGGREGATING multiple backend calls into one response for the client (the "Backend for Frontend" pattern).

Question 32

What is service discovery and why is it needed in a microservices architecture?

Accepted Answer

In a microservices system, service INSTANCES are constantly CHANGING — new instances start (scaling up), old ones stop (scaling down, deploys, crashes), and each gets a DIFFERENT IP address (especially in containerized/cloud environments). SERVICE DISCOVERY is the mechanism by which one service finds the CURRENT network location(s) of another service, WITHOUT hardcoding IPs. There are two main patterns: CLIENT-SIDE discovery (the calling service queries a REGISTRY like Consul/etcd directly and picks an instance) and SERVER-SIDE discovery (the calling service talks to a fixed address — like a load balancer — which queries the registry on its behalf).

Question 33

What are Event Sourcing and CQRS? When would you use them?

Accepted Answer

EVENT SOURCING means storing the STATE of an entity not as its CURRENT VALUES, but as a SEQUENCE OF EVENTS that led to that state — e.g., instead of "account.balance = 500", you store "[AccountOpened, Deposited(200), Deposited(400), Withdrew(100)]" and the balance is COMPUTED by REPLAYING these events. CQRS (Command Query Responsibility Segregation) SEPARATES the model used for WRITES (commands — validated, business-logic-heavy) from the model used for READS (queries — denormalized, optimized for display) — they can use ENTIRELY DIFFERENT data stores. The two PAIR NATURALLY: events from the write side are used to BUILD/UPDATE the read-side "projections".

Question 34

How would you design a distributed job scheduler (like a distributed cron) that runs scheduled tasks reliably?

Accepted Answer

A distributed job scheduler must run scheduled tasks (e.g., "send a reminder email at 3pm", "run this report every night at midnight") EXACTLY as scheduled, EXACTLY ONCE, even though it runs across MULTIPLE worker machines (for scale/redundancy). Core pieces: a JOB STORE (database of "{ jobId, schedule (cron expression or specific time), nextRunAt, status }"), a SCHEDULER process that periodically scans for jobs whose "nextRunAt" has PASSED and DISPATCHES them to a QUEUE (recall [[sd-10]]), WORKERS that consume from the queue and EXECUTE jobs, and DISTRIBUTED LOCKING (recall [[sd-22]]) to ensure that if MULTIPLE scheduler instances are running (for redundancy), only ONE actually dispatches a given job at its scheduled time.

Question 35

How would you design the inventory management system for an e-commerce platform, ensuring no overselling?

Accepted Answer

Inventory management must prevent OVERSELLING (selling more units than physically available) while remaining FAST under high concurrency (flash sales — thousands of users trying to buy the LAST few units simultaneously). The core technique is ATOMIC DECREMENT with a CONSTRAINT: "UPDATE inventory SET quantity = quantity - 1 WHERE product_id = X AND quantity > 0" — this single SQL statement ATOMICALLY checks-and-decrements, returning 0 rows affected if insufficient stock (handling the race condition WITHOUT explicit locking). For checkout flows, a RESERVATION system temporarily HOLDS inventory during the payment process (released if payment fails/times out) to avoid "pay for an item that sold out during checkout".

System Design

How would you design a URL shortener like bit.ly?

What is the CAP theorem? How does it affect database choice?

Explain horizontal vs vertical scaling. When would you choose each?

What is consistent hashing and why is it used in distributed systems?

What is the difference between SQL and NoSQL databases? When would you choose each?

What load balancing algorithms exist, and how do you choose between them?

What are the main caching strategies (cache-aside, write-through, write-behind) and eviction policies?

How does database sharding work? What are the challenges of choosing a shard key?

Explain database replication: master-slave vs master-master, and synchronous vs asynchronous replication.

Compare message queue systems: Kafka vs RabbitMQ vs SQS. When would you use each?

What rate limiting algorithms exist (token bucket, leaky bucket, sliding window)? How would you implement a distributed rate limiter?

How does a CDN (Content Delivery Network) work, and what should and should not be cached on it?

Compare microservices and monolithic architecture. When should a team migrate from monolith to microservices?

How would you design the backend architecture for a real-time chat application like WhatsApp or Slack?

How would you design a news feed system (like Facebook or Twitter/X)? Explain the fan-out-on-write vs fan-out-on-read trade-off.

What is the Circuit Breaker pattern? How does it help microservices handle failures gracefully?

What does idempotency mean in distributed systems, and how do you design idempotent APIs?

How would you design a globally unique ID generator for a distributed system (like Twitter's Snowflake)?

How would you design a search autocomplete / typeahead system (like Google Search suggestions)?

How do database indexes work, and how do you decide what to index?

What are database transaction isolation levels? Explain dirty reads, non-repeatable reads, and phantom reads.

How do distributed locks work? What problems can arise with naive implementations using Redis?

How would you design a distributed key-value store (like a simplified DynamoDB or Redis Cluster)?

How would you design the backend for a video streaming platform like YouTube or Netflix?

How would you design a web crawler that can index billions of pages?

How would you design a distributed file storage system like Dropbox or Google Drive?

How would you design a payment processing system that handles money safely?

How would you design the backend for a ride-sharing app like Uber, focusing on driver-rider matching?

How would you design a notification system that sends push, email, and SMS at scale?

What is leader election and how do consensus algorithms like Raft work at a high level?

What is an API Gateway and what responsibilities does it handle in a microservices architecture?

What is service discovery and why is it needed in a microservices architecture?

What are Event Sourcing and CQRS? When would you use them?

How would you design a distributed job scheduler (like a distributed cron) that runs scheduled tasks reliably?

How would you design the inventory management system for an e-commerce platform, ensuring no overselling?

Practice & learn this topic

System Design

How would you design a URL shortener like bit.ly?

What is the CAP theorem? How does it affect database choice?

Explain horizontal vs vertical scaling. When would you choose each?

What is consistent hashing and why is it used in distributed systems?

What is the difference between SQL and NoSQL databases? When would you choose each?

What load balancing algorithms exist, and how do you choose between them?

What are the main caching strategies (cache-aside, write-through, write-behind) and eviction policies?

How does database sharding work? What are the challenges of choosing a shard key?

Explain database replication: master-slave vs master-master, and synchronous vs asynchronous replication.

Compare message queue systems: Kafka vs RabbitMQ vs SQS. When would you use each?

What rate limiting algorithms exist (token bucket, leaky bucket, sliding window)? How would you implement a distributed rate limiter?

How does a CDN (Content Delivery Network) work, and what should and should not be cached on it?

Compare microservices and monolithic architecture. When should a team migrate from monolith to microservices?

How would you design the backend architecture for a real-time chat application like WhatsApp or Slack?

How would you design a news feed system (like Facebook or Twitter/X)? Explain the fan-out-on-write vs fan-out-on-read trade-off.

What is the Circuit Breaker pattern? How does it help microservices handle failures gracefully?

What does idempotency mean in distributed systems, and how do you design idempotent APIs?

How would you design a globally unique ID generator for a distributed system (like Twitter's Snowflake)?

How would you design a search autocomplete / typeahead system (like Google Search suggestions)?

How do database indexes work, and how do you decide what to index?

What are database transaction isolation levels? Explain dirty reads, non-repeatable reads, and phantom reads.

How do distributed locks work? What problems can arise with naive implementations using Redis?

How would you design a distributed key-value store (like a simplified DynamoDB or Redis Cluster)?

How would you design the backend for a video streaming platform like YouTube or Netflix?

How would you design a web crawler that can index billions of pages?

How would you design a distributed file storage system like Dropbox or Google Drive?

How would you design a payment processing system that handles money safely?

How would you design the backend for a ride-sharing app like Uber, focusing on driver-rider matching?

How would you design a notification system that sends push, email, and SMS at scale?

What is leader election and how do consensus algorithms like Raft work at a high level?

What is an API Gateway and what responsibilities does it handle in a microservices architecture?

What is service discovery and why is it needed in a microservices architecture?

What are Event Sourcing and CQRS? When would you use them?

How would you design a distributed job scheduler (like a distributed cron) that runs scheduled tasks reliably?

How would you design the inventory management system for an e-commerce platform, ensuring no overselling?

Practice & learn this topic