Senior Case Studies Interview Questions (50 MCQs)

Question 1

Time is limited in the interview's deep-dive phase. Which part should you choose to go deep on?

Accepted Answer

The component under the most pressure from the key non-functional requirement

Answer

Whichever part has the most services in the diagram

Answer

Whatever you have most experience with, regardless of the problem

Answer

Every component equally and superficially

Question 2

You design both a news feed and seat booking in one interview. How should consistency choices differ?

Accepted Answer

The feed can be eventual; seat allocation needs strong consistency

Answer

Both must be strong because user data matters

Answer

Both can be eventual with conflicts resolved later

Answer

The feed must be strong and booking eventual

Question 3

A monitoring system ingests 1M points/sec at 16 raw bytes each. What's the daily estimate and design takeaway?

Accepted Answer

About 1.4 TB/day; compression like Gorilla and downsampling are essential

Answer

About 14 GB/day; one ordinary disk suffices for years

Answer

About 140 TB/day; storing metrics is practically impossible

Answer

About 140 GB/day; no retention policy is needed

Question 4

Product wants short link destinations to be editable or revocable later. What's the consequence of choosing `301`?

Accepted Answer

Browsers may cache the old destination indefinitely so changes never reach them

Answer

`301` makes the link expire automatically after 24 hours

Answer

`301` doesn't allow forwarding the query string

Answer

`301` is only supported in desktop browsers

Question 5

A URL shortener runs active-active in three regions. How do codes stay unique without cross-region coordination per write?

Accepted Answer

Partition the key space across regions (e.g., a region bit or prefix)

Answer

Confirm every write with global consensus across the three regions

Answer

Use a short URL hash and ignore collisions

Answer

Let only one region accept writes and keep others read-only

Question 6

An ID service autoscales on Kubernetes. What's the most dangerous issue in assigning worker IDs to pods?

Accepted Answer

Two pods holding the same worker ID produce duplicates; leases with TTL are needed

Answer

Pods cannot read the system clock

Answer

Snowflake cannot run in containers

Answer

The worker ID must always equal the pod IP

Question 7

A team wants to determine exact cross-service event order by comparing Snowflake IDs. What's the problem?

Accepted Answer

IDs from different machines are only roughly ordered; clock skew breaks causal ordering

Answer

Snowflake IDs are fully random with no ordering

Answer

Comparing 64-bit numbers isn't possible in most languages

Answer

Snowflake IDs reset every second

Question 8

A legal requirement says invoice numbers must be contiguous with no gaps. What's the design implication?

Accepted Answer

A serialized, transactional sequencer (e.g., per entity) with accepted throughput limits

Answer

Snowflake suffices since its IDs are contiguous

Answer

A normal DB sequence suffices because it never has gaps

Answer

UUID v7 solves it because it's time-ordered

Question 9

An API key must respect 1,000 req/min across three regions. Which approach makes a reasonable trade-off?

Accepted Answer

Local per-region counters synced asynchronously, accepting slight temporary overage

Answer

Checking one central Redis in a single region for every request

Answer

Statically splitting the limit to 333 per region regardless of traffic

Answer

Removing rate limits for international traffic

Question 10

The Redis behind the rate limiter is down. Which behavior is usually more sensible for a public API, and why?

Accepted Answer

Fail open with a conservative local limit so a limiter outage doesn't take down the API

Answer

Fail closed and reject everything until Redis returns

Answer

Wait on Redis per request up to a 30-second timeout

Answer

Disable authentication entirely to reduce load

Question 11

One big customer sends 200K req/s and their counter makes a single Redis shard hot. What's the best fix?

Accepted Answer

Each instance leases batches of tokens and consumes them locally

Answer

Configure the key with a shorter TTL

Answer

Route all that customer's requests to one app server

Answer

Move Redis to a faster SSD disk

Question 12

In the hybrid model, a user follows 3,000 celebrity accounts and their feed is slow. Cause and fix?

Accepted Answer

Pulling and merging 3,000 timelines on read; cache celebrity timelines and do a bounded top-N merge

Answer

Fan-out on write is too slow for this user; remove push

Answer

The posts DB lacks an index; add one

Answer

This user's WebSocket is disconnected; reconnect

Question 13

With fan-out on write, a post is deleted or a user unfollows. What's the most efficient way to purge it from precomputed feeds?

Accepted Answer

Filter at hydration time on read, plus gradual async cleanup

Answer

Synchronously remove it from millions of followers' feeds before responding

Answer

Rebuild every user's feed in the system

Answer

Ignore it; show the deleted post until cache expiry

Question 14

The feed is rank-ordered (not chronological) and scores keep changing. How do we avoid duplicates or gaps while scrolling?

Accepted Answer

Materialize a ranked snapshot of IDs per session and page through it with a cursor

Answer

A cursor on the last item's score re-querying the live ranking

Answer

Offset pagination over the live ranking

Answer

Re-sort the entire feed for every page

Question 15

How does a chat client detect it has missed a message (e.g., after a brief network drop)?

Accepted Answer

Via a contiguous per-conversation sequence; a gap triggers a sync request

Answer

By comparing message timestamps with the local device clock

Answer

The server sends the full message list every 24 hours

Answer

It's impossible; messages are lost forever

Question 16

A chat channel has 500K members. What's wrong with writing each message into every member's inbox, and the alternative?

Accepted Answer

Massive write amplification; store once in the channel log and have members read from it

Answer

Messages aren't encrypted; enable E2E

Answer

Message order is preserved, which is unnecessary

Answer

No problem; per-user inboxes are always best

Question 17

Deploying a WebSocket server with 1M connections caused simultaneous reconnects and overload. What should be done?

Accepted Answer

Gradual connection draining and client reconnects with backoff and jitter

Answer

Raise connection timeouts to one hour

Answer

Deploy only during peak traffic hours

Answer

Replace WebSocket with one-second short polling

Question 18

Adding end-to-end encryption to a chat app makes which server-side capability practically impossible?

Accepted Answer

Server-side full-text search and content moderation of messages

Answer

Sending delivery receipts

Answer

Routing messages between WebSocket servers

Answer

Storing messages for offline users

Question 19

A user is logged in on phone, laptop, and tablet. Which model correctly syncs messages and 'read' state?

Accepted Answer

A per-device delivery cursor plus a per-user read marker synced across devices

Answer

One shared cursor for all devices

Answer

Only the most recently active device receives messages

Answer

Each device has a separate account

Question 20

The order service commits to the DB, then publishes a notification event to Kafka; crashes in between lose notifications. What's the standard fix?

Accepted Answer

Transactional outbox: write the event in the same DB transaction and relay it afterward

Answer

Publish to Kafka first, then commit to the DB

Answer

Use two-phase commit between the DB and the SMS provider

Answer

Increase the Kafka connection timeout

Question 21

A marketing campaign enqueued 50M notifications and login OTPs now arrive 10 minutes late. What's the architectural fix?

Accepted Answer

Separate queues and workers by priority, with reserved capacity for transactional

Answer

Add partitions to the same shared queue

Answer

Restrict OTPs to off-peak hours

Answer

Send campaigns at the same priority as OTPs for fairness

Question 22

A crawler's Bloom filter over 10B URLs has a 1% false positive rate. What's the practical consequence?

Accepted Answer

About 1% of new URLs are never crawled; size bits and hash count for an acceptable rate

Answer

About 1% of pages are crawled twice, merely adding cost

Answer

The Bloom filter forgets 1% of seen URLs

Answer

No consequence since false positives are harmless

Question 23

A crawler must keep the index fresh on a limited budget. How should page recrawls be scheduled?

Accepted Answer

By observed change rate and page importance, with an adaptive per-URL interval

Answer

All pages on a fixed one-month interval

Answer

Only pages users have reported

Answer

Randomly and uniformly

Question 24

In a distributed crawler, by what key should URLs be partitioned across workers?

Accepted Answer

Hash of the hostname, so politeness, DNS, and `robots.txt` caching stay local

Answer

Hash of the full URL, for perfectly uniform distribution

Answer

Round-robin by discovery order

Answer

URL length

Question 25

A breaking news event happened and the weekly trie doesn't reflect it. How do we add trending suggestions with minimal delay?

Accepted Answer

A streaming layer with windowed, time-decayed counts merged with base trie results

Answer

Fully rebuild the trie after every query

Answer

Have on-call engineers add terms manually

Answer

Shrink the offline rebuild interval to one second

Question 26

In an LSM-based eventually consistent KV store, why might a deleted key 'come back to life'?

Accepted Answer

The tombstone was purged before reaching a replica that was down, and anti-entropy restored old data

Answer

LSM trees don't support deletes

Answer

The client cached the key after deleting it

Answer

Consistent hashing moved the key to another node

Question 27

A KV store uses last-write-wins on server timestamps. One node's clock is 5 seconds ahead. What happens?

Accepted Answer

That node's writes override genuinely newer writes, silently losing data

Answer

The node is automatically removed from the cluster

Answer

All writes are rejected with an error

Answer

No effect because LWW doesn't depend on clocks

Question 28

Why do consistent-hashing KV stores use virtual nodes (vnodes)?

Accepted Answer

More even distribution, spreading rebuild load across nodes, and weighting stronger hardware

Answer

Eliminating the need for replication

Answer

Guaranteeing strong consistency

Answer

Reducing hash functions to one

Question 29

In HLS live streaming, what trade-off comes from cutting segment length from 6s to 1s?

Accepted Answer

Lower latency, but more requests, worse compression, and higher rebuffering risk

Answer

Higher latency but better image quality

Answer

No need for a CDN anymore

Answer

No cost; it is always better

Question 30

A hit show's new episode drops and millions of simultaneous requests cause cache misses at hundreds of edges, hammering the origin. Fix?

Accepted Answer

An origin shield (mid-tier cache) with request coalescing and CDN pre-warming

Answer

Reduce the CDN cache TTL to one second

Answer

Serve all users directly from origin

Answer

Increase segment size to 60 seconds

Question 31

A user inserts one byte at the start of a 1 GB file. What happens with fixed-size chunking, and how does content-defined chunking differ?

Accepted Answer

Fixed-size shifts every boundary and re-uploads everything; CDC with a rolling hash preserves boundaries

Answer

Both re-upload only the first chunk

Answer

Fixed-size re-uploads only the first chunk, but CDC the entire file

Answer

Neither detects any change

Question 32

A storage service does client-side cross-user dedup (skipping upload if the hash exists). What's the security risk?

Accepted Answer

An attacker can learn a specific file exists for another user by seeing the upload skipped

Answer

Hashes can be reversed into file contents

Answer

Dedup prevents files from being encrypted

Answer

Files become co-editable between users

Question 33

In file sync, what's the correct order of uploading chunks and updating metadata?

Accepted Answer

Upload all chunks to block storage first, then atomically commit the new version in metadata

Answer

Update metadata first, then upload chunks

Answer

Commit each chunk to metadata separately as it uploads

Answer

Order doesn't matter since it becomes consistent eventually

Question 34

Uber uses H3 (a hexagonal grid) rather than geohash for supply/demand analysis. What's the key hexagon advantage?

Accepted Answer

All 6 neighbors are equidistant center to center, simplifying neighborhood analysis and smoothing

Answer

Hexagons subdivide exactly into 4 children with no remainder

Answer

H3 requires no computation on coordinates

Answer

Hexagons produce strings searchable by prefix

Question 35

Two matchers concurrently pick the same driver for two riders. How do we prevent double dispatch?

Accepted Answer

Atomically compare-and-set the driver state (available → offered) and retry the loser

Answer

Let the driver choose between both and let the other time out

Answer

Run only one matcher for the entire world

Answer

Prioritize riders alphabetically

Question 36

Matching is sharded by city and a big concert ending overloads one city's shard. What's the design improvement?

Accepted Answer

Shard by fine-grained geospatial cells that can be dynamically split and rebalanced

Answer

Put all cities into a single shard

Answer

Send overflow requests to another city's shard lacking local data

Answer

Limit the number of riders per concert

Question 37

Why is an in-memory quadtree good for static businesses (Yelp) but less suited to moving driver locations?

Accepted Answer

Constant updates require moving points and frequently splitting/merging nodes

Answer

Quadtrees only work for southern hemisphere coordinates

Answer

Quadtrees can't hold more than a thousand points

Answer

Quadtrees don't support nearest-neighbor search

Question 38

A game leaderboard has 500M players and must show each player's rank. One sorted set no longer suffices. Which design fits?

Accepted Answer

Shard by score range; rank = sum of higher shards' sizes + local rank

Answer

Shard by user ID hash and scan all shards per rank

Answer

Compute rank with `ORDER BY` over the whole SQL table per request

Answer

Store rank as a static field updated monthly

Question 39

In a leaderboard, the player who reached a score first should rank higher. How do you implement it with a Redis Sorted Set?

Accepted Answer

A composite score: points in the high part and (max time − timestamp) in the low part

Answer

Rely on lexicographic member order for tie-breaks

Answer

Keep two separate sorted sets and merge in the client

Answer

Redis automatically breaks ties by insertion time

Question 40

A charge request to the PSP timed out and we don't know whether money was taken. What's the correct behavior?

Accepted Answer

Keep it pending and retry with the same idempotency key or query the PSP for status

Answer

Immediately charge again with a new idempotency key

Answer

Mark it failed and tell the user to try again

Answer

Assume success and ship the order

Question 41

Two requests with the same idempotency key arrive concurrently and both find nothing in the key table. What's the correct implementation?

Accepted Answer

Atomically insert the key as in-progress under a unique constraint; the second gets `409` or waits

Answer

Charge first, then store the key

Answer

Keep keys only in each instance's local memory

Answer

Process whichever has the smaller timestamp, without locking

Question 42

A transfer across a wallet service and a ledger service (separate databases) must stay consistent. Which approach is more common in microservices?

Accepted Answer

A saga with idempotent steps and compensating transactions on failure

Answer

Synchronous two-phase commit across all services and the external PSP

Answer

Write to both databases uncoordinated and hope

Answer

Merge all services into one shared database per transaction

Question 43

In a multi-currency payment data model, how should amounts be stored?

Accepted Answer

An integer in the currency's minor unit along with the currency code (ISO 4217)

Answer

A `float` or `double` in the major unit

Answer

A formatted string like '12,500 USD'

Answer

An integer without currency, inferred from the user's country

Question 44

Ticket sales open for a 50K-seat concert with 5M users. Which design protects the system and is fair?

Accepted Answer

A virtual waiting room with signed queue tokens and controlled admission to checkout

Answer

Unlimited database autoscaling at sale start

Answer

Accept all requests and refund the extras

Answer

Show a random `503` to 90% of users

Question 45

A flash-sale item's stock lives in one SQL row and `UPDATE ... SET stock = stock - 1 WHERE stock > 0` is slow under heavy load. Cause and improvement?

Accepted Answer

The hot row's lock serializes everything; split stock into sub-rows/buckets or keep it in Redis

Answer

The query is wrong and causes oversell

Answer

We should add a separate `SELECT` before the `UPDATE`

Answer

An index on the stock column fixes it

Question 46

A developer added a `user_id` label to the `http_requests_total` metric and the TSDB fell over. Why?

Accepted Answer

Each label combination is a separate series; millions of users explode cardinality

Answer

Labels cannot hold numeric values

Answer

Counters must never have labels

Answer

`user_id` is PII and the TSDB rejects it

Question 47

Each server reports its own p99 latency and the dashboard averages them as the overall p99. What's wrong?

Accepted Answer

Percentiles can't be averaged; merge histograms or sketches, then compute the percentile

Answer

We should sum the p99s instead of averaging

Answer

p99 always equals the mean, so it's fine

Answer

Multiply each server's p99 by its CPU count

Question 48

The old scheduler leader hit a long GC pause, its lease expired and a new leader was elected; then the old one woke and re-ran a job. Principled fix?

Accepted Answer

A monotonically increasing fencing token that downstream resources use to reject stale holders

Answer

Extend the lease duration to one hour

Answer

Have the leader check the system clock before each action

Answer

Run two leaders permanently for safety

Question 49

A scheduler holds billions of scheduled jobs and a `WHERE run_at <= now()` query on one table is slow and contended. Better design?

Accepted Answer

Partition by time bucket (e.g., per minute) and shard, with each worker claiming its own buckets

Answer

Run the same query every millisecond

Answer

Load the entire table into one server's RAM

Answer

Drop `run_at` and run all jobs immediately

Question 50

Each node keeps local counts and sends only its top-10 to an aggregator. Why may the global top-10 be wrong, and the fix?

Accepted Answer

An item ranked 11th on every node may be first overall; send mergeable sketches or a larger top-N

Answer

The aggregator cannot sort lists

Answer

Local counts are always exact, so the result is always correct

Answer

Top-K can only be computed on one node