Full-stack engineer system design interview questions

As asked

Design a URL shortener service that stores 10 billion URLs, handles 100K redirects per second, and generates unique 7-character short codes. Walk me through storage, ID generation, and caching.

Sample answer outline

For ID generation: base62 encoding of a counter from a distributed ID generator (Snowflake or a Postgres sequence with a hash). Storage: Postgres or DynamoDB for the mapping table; 10 billion rows at ~200 bytes each is around 2 TB, which is manageable with sharding on the short code. Redirects at 100K/s require Redis caching of the hot URLs; the cache hit rate for a short-URL service is very high because popular links get most of the traffic. Read path: check Redis, miss goes to DB, populate cache with TTL. Analytics: async write to a Kafka topic from the redirect service. The candidate should discuss eventual consistency for analytics vs strong consistency for URL creation.

Expect these follow-ups

• How do you prevent the cache stampede when a newly-viral URL is first accessed by millions of users?
• How would you implement custom slugs (like bit.ly/mylink) and handle slug collisions?

As asked

Adobe Creative Cloud has over 30 million paying subscribers. Describe how your design and engineering approach changes when you know a feature will be used at that scale from day one, compared to building something for a few thousand internal users.

Sample answer outline

Strong answers cover progressive rollout strategies (feature flags, canary deployments), observability from day one (structured logging, real-user monitoring), designing for partial failures so one region or cohort does not take down the whole fleet, and understanding that performance regressions at this scale have real revenue consequences. A great candidate also mentions backward compatibility and how a bad update to Photoshop or Lightroom can break professional workflows globally.

Expect these follow-ups

• How do you handle a hot path where 1% of requests come from 30% of your traffic?
• What is your rollback strategy if a deploy breaks a rendering pipeline?

As asked

Design the backend system that powers Airbnb's listing search. A guest enters a location, dates, and guest count. Walk me through how you would retrieve, filter, and rank listings at scale. Assume tens of millions of active listings globally.

Sample answer outline

A strong answer covers: geo-spatial indexing (PostGIS or Elasticsearch geo queries) for location filtering, availability indexing (calendar bitmap or a separate availability service) for date filtering, a two-phase retrieval-then-ranking pipeline, and a ranking model that combines price, reviews, availability probability, and personalization signals. The candidate should discuss consistency vs. latency tradeoffs in the availability check, and how to handle the cold-start problem for new listings.

Expect these follow-ups

• How do you handle the availability calendar when a host blocks dates in real time while a search is in flight?
• Walk me through how you would A/B test a change to the ranking model.

As asked

Design the system that handles an Airbnb booking from the moment a guest clicks 'Reserve' to the moment the host's payout is released after checkout. Focus on correctness, consistency, and failure handling.

Sample answer outline

Strong answers identify the core challenge as a distributed transaction spanning inventory (availability), payment authorization, and notification. They describe an optimistic lock on the listing calendar, a saga pattern or two-phase commit for the payment flow, idempotency keys for retries, and a state machine for the reservation lifecycle (pending, confirmed, checked-in, completed, cancelled). The candidate should address what happens when payment succeeds but the database write fails.

Expect these follow-ups

• How do you handle double-booking when two guests book the same listing at the exact same millisecond?
• When the host cancels after payment is captured, walk me through every system that needs to update.

As asked

Design a URL shortener service. It needs to handle 100 million new URLs per day and serve redirect requests at 10x that volume. Walk me through your high-level design, your choice of data store, and how you ensure low latency on the redirect path.

Sample answer outline

A strong answer starts with back-of-envelope math: 100M writes per day is about 1,200 writes/s, and 10x reads gives 1B reads per day, which is about 11,500 reads/s. The candidate should separate the write path (hash generation, storage) from the read path (cache-heavy, low latency). Key decisions include: base62 encoding of an auto-increment ID or MD5 prefix for the short code, a SQL or NoSQL store (DynamoDB fits well at Amazon), a distributed cache (ElastiCache/Redis) in front of the DB for the redirect path, and a CDN for the most popular URLs. Candidates should mention what happens on a hash collision.

Expect these follow-ups

• How do you handle custom short codes that a user picks?
• How would you add analytics to track click counts without impacting redirect latency?

As asked

Design the sync system that keeps photos consistent across a user's iPhone, iPad, Mac, and iCloud. Focus on conflict resolution, offline support, and bandwidth efficiency.

Sample answer outline

A strong answer treats the device as the source of truth per photo, identifies each photo by a stable UUID, and uses last-write-wins at the asset level since photos are immutable once captured. Conflict resolution is simpler than for text because photos do not merge: if the same UUID appears on two devices with different content, the one with the later capture timestamp wins. Bandwidth efficiency needs delta sync (upload only new assets), HEIC compression, and thumbnail-first loading. Offline support requires a local queue of pending operations that replay on reconnect. The candidate should touch on how to handle device key loss in end-to-end encryption scenarios.

Expect these follow-ups

• How do you handle the case where a user deletes a photo on one device while it is being downloaded on another?
• How does your design change if you need to sync edits to a photo, not just the original?

As asked

A user requests a crypto withdrawal. Your system must ensure the same funds cannot be spent twice, even if two withdrawal requests arrive simultaneously and the database write and the blockchain broadcast are not atomic. Walk me through how you would design this.

Sample answer outline

A strong answer introduces an idempotency key on the request, a state machine for withdrawal lifecycle (pending, reserved, broadcast, confirmed, failed), and a pessimistic lock or SELECT FOR UPDATE on the balance row before decrementing. The candidate should explain why optimistic locking is riskier here than in typical CRUD, discuss how to handle the gap between DB commit and chain broadcast using an outbox pattern or at-least-once worker with idempotent broadcast, and address what happens on timeout or partial failure.

Expect these follow-ups

• How does your design change if you need to support withdrawals across multiple chains with different confirmation times?
• What happens if the blockchain node your system talks to goes down after you deduct the balance but before broadcast?

As asked

Design a system that ingests time-series metrics from 100,000 hosts, each emitting 1,000 metrics every 10 seconds. The system must store metrics for 15 months, support fast range queries for dashboards, and handle a 10x traffic spike without dropping data. Walk me through your architecture.

Sample answer outline

A strong answer describes the ingestion layer (agents, protocol choice between StatsD/OpenTelemetry, connection pooling), a durable buffer (Kafka or similar) to absorb spikes, a write path that aggregates at the edge before writing to a columnar or time-series store (InfluxDB, TimescaleDB, or a custom LSM-based store), a tiered retention strategy (high-resolution for recent data, downsampled for older), and a read path that answers range queries efficiently using pre-computed rollups. The candidate should reason explicitly about cardinality limits and tag index cost.

Expect these follow-ups

• How does your design change if you also need to support 1-second resolution for the most recent hour?
• How would you handle a customer who creates a metric with 10 million unique tag combinations?

As asked

Design Datadog's APM distributed tracing system from scratch. I need it to collect traces from thousands of microservices, correlate spans into complete traces, store them efficiently for 30 days, and let users query by service, operation, error status, and latency percentile in near real time.

Sample answer outline

A strong answer covers trace context propagation (W3C TraceContext or B3 headers), agent-side head-based and tail-based sampling strategies and their tradeoffs, a collection tier that reassembles incomplete spans using a trace ID keyed buffer, a write path to a wide-column or columnar store optimized for trace assembly, and a query path that supports filtering by service graph edges. The candidate should address the fundamental tension between sampling (cost control) and completeness (not missing rare errors).

Expect these follow-ups

• How does tail-based sampling differ from head-based sampling, and what infrastructure does it require?
• How would you store span data so you can answer 'show me all traces with p99 latency over 500ms in the last hour' in under 2 seconds?

As asked

DoorDash has tens of thousands of Dashers on the road at peak hours. Design the backend system that tracks Dasher location in real time, detects when a delivery is at risk of being late, and triggers automated interventions like reassignment. Walk me through your data model, your event pipeline, and how you handle the case where a Dasher goes offline mid-delivery.

Sample answer outline

Strong answers define a location event pipeline (Kafka or Pub/Sub) ingesting GPS pings at 5 to 10 second intervals, a stateful stream processor computing ETA vs. promised delivery time, and a risk-scoring service that fires reassignment events when the gap exceeds a threshold. The candidate should address geo-spatial indexing (PostGIS or H3), at-least-once delivery guarantees, and the consumer-offline edge case using a heartbeat timeout with graceful handoff logic rather than immediate reassignment.

Expect these follow-ups

• How does your design change at 10x Dasher volume during a Super Bowl peak?
• How would you A/B test a new reassignment threshold without hurting real customers?

As asked

Design the system that keeps a user's files consistent across all their devices. Focus on the data flow when a file changes on one device and needs to propagate to others. Assume hundreds of millions of files and tens of millions of daily active users. Walk me through every component you would build.

Sample answer outline

A strong answer covers: chunking files into 4MB blocks and hashing each block (content-addressable storage) so only changed chunks are uploaded; a metadata service that stores file version history, block lists, and device cursors (what each device last synced); a notification service (long-poll or WebSocket) to push change events to other devices; block storage on S3 with CDN for downloads; a conflict resolution strategy (Dropbox creates conflicted copies rather than auto-merging); and the sync client algorithm (upload new blocks, update metadata, pull changes for other devices). The candidate should discuss eventual consistency and what happens during partition.

Expect these follow-ups

• How do you handle a 50GB file where only 10 bytes changed?
• How do you decide the optimal chunk size, and what are the tradeoffs of smaller versus larger chunks?

As asked

Figma supports real-time collaborative editing where dozens of people can edit the same file simultaneously. Walk me through how you would design the data synchronization layer for this. How do you handle conflicts when two users move the same object at the same time?

Sample answer outline

A strong answer covers operational transformation or CRDTs as the two main approaches, explains why Figma uses a server-authoritative model with a central server that serializes all operations rather than a pure peer-to-peer CRDT approach, and discusses the tradeoff between complexity and correctness. The candidate should explain how vector clocks or sequence numbers track causality, how the client applies optimistic local updates and rolls back on conflict, and how presence (cursors, selection highlights) is handled as ephemeral state separate from document state. They should mention that Figma publishes engineering posts explaining their choices.

Expect these follow-ups

• If the server goes down mid-edit, how does a client know which local operations were acknowledged?
• How would you handle the case where one user deletes a frame that another user is actively editing inside of?

As asked

Design a real-time collaborative document editing system similar to Google Docs. Multiple users should be able to edit the same document simultaneously, see each other's cursors, and have a consistent view of the document at all times. Walk me through your architecture.

Sample answer outline

A strong answer covers operational transformation (OT) or CRDT as the conflict resolution mechanism, explains the difference, and picks one with justification. The architecture should include a document server, a presence/cursor service, durable storage (document snapshots plus operation log), and a WebSocket or long-polling layer for real-time updates. The candidate should address consistency (what happens when two edits arrive out of order), persistence (how to reconstruct a document from its operation log), and latency (optimistic local application before server confirmation).

Expect these follow-ups

• How would you handle the case where a user goes offline for 5 minutes then reconnects?
• How do you support the revision history feature that lets users rewind to any point in time?

As asked

Design a URL shortening service similar to what Google built with goo.gl (now shut down). Users submit a long URL and get back a short URL. When someone visits the short URL, they are redirected to the original. The service must handle 1 billion URLs and 100,000 redirect requests per second globally. Describe your architecture.

Sample answer outline

A strong answer covers: generating short codes (base62 encoding of a counter or hash, with collision handling), storing the mapping (a key-value store like Bigtable or Spanner with the short code as the key), serving redirects via a CDN-cached layer for popular URLs with a hot cache for the long tail, and handling the write path with a counter or distributed ID generator. The candidate should address analytics (click counting) as a separate asynchronous write to avoid slowing redirects.

Expect these follow-ups

• How do you prevent collisions if you are using a random hash?
• How would you add custom aliases, like goo.gl/myAlias, without slowing down the lookup?

As asked

Design the system that powers LinkedIn's home feed: each member sees a ranked, paginated list of updates from their connections and followed entities, with roughly 900 million members and hundreds of millions of daily active users. Walk me through your architecture.

Sample answer outline

A strong answer covers fan-out strategy (push vs pull vs hybrid based on follower count), a ranking service that applies machine-learning signals (relevance, recency, engagement), a timeline store (Kafka for event ingestion, distributed key-value for precomputed timelines), and CDN/caching layers. The candidate should call out the celebrity problem (high-degree nodes), stale feed risk, and how to handle real-time vs eventual consistency for feed updates.

Expect these follow-ups

• How would you handle a member with 10 million followers posting an update?
• How does your design degrade gracefully when the ranking service is slow or down?

As asked

Design Lyft's ride-matching service. When a rider requests a ride, the system needs to match them to a driver in real time. Walk me through your data model, the matching algorithm, and how you handle edge cases like no available drivers, surge zones, and network partitions.

Sample answer outline

Strong answers cover geospatial indexing (geohash or quadtree for nearby driver lookup), a scoring function that weighs distance, ETA, and driver rating, a queuing or polling mechanism for driver state, and eventual-consistency trade-offs when partitions occur. They should also address how to handle the case where a driver goes offline between match and acceptance.

Expect these follow-ups

• How would you change the design if Lyft moved from a driver-accept model to auto-dispatch?
• How do you prevent the same driver from being matched to two riders simultaneously?

As asked

Design the News Feed system for Facebook. Start with clarifying questions, walk me through the high-level architecture, then go deep on the feed generation and ranking components.

Sample answer outline

A strong answer covers the fan-out write model versus fan-out read, when to use each (celebrities versus normal users), the role of a feed store like TAO or a cache like Memcached, and how ranking scores are computed offline versus online. The candidate should discuss the trade-off between freshness and ranking quality, and how you handle users with millions of followers without blowing up write amplification.

Expect these follow-ups

• How does your design change if you add Stories on top of Feed with a 24-hour expiry?
• Walk me through what happens when a user with 50 million followers posts.

As asked

Design the backend for a messaging product like Messenger or WhatsApp. Focus on message delivery guarantees, real-time presence, and how you handle a user receiving messages across multiple devices.

Sample answer outline

A strong answer covers the message store (append-only log per conversation, similar to Scribe), the use of long-polling or WebSockets for real-time delivery, how delivered and read receipts are tracked without blocking the sender, and how multi-device fanout works. The candidate should explain exactly-once delivery semantics and how deduplication is achieved with client-side idempotency keys.

Expect these follow-ups

• How do you handle end-to-end encryption without breaking your server-side search and moderation features?
• What happens when a user comes back online after being offline for three days?

As asked

Microsoft makes OneDrive. Design a cloud file storage service that supports uploading and downloading files up to 5 GB, organizing them in folders, sharing with other users at different permission levels, and syncing changes across multiple devices. Walk me through the components you would build.

Sample answer outline

Strong answers cover the metadata service (file hierarchy, permissions, versioning) separately from blob storage (chunked upload via Azure Blob or S3-equivalent, deduplication). The sync protocol should address conflict resolution, delta sync, and client-side chunking. Sharing needs an ACL model. The candidate should call out CDN usage for popular downloads, handle resumable uploads for large files, and discuss how change notifications propagate to devices. Candidates interviewing at Microsoft should tie this to Azure infrastructure where natural.

Expect these follow-ups

• How do you handle conflict resolution when two devices edit the same file offline?
• How would you support 100 million concurrent users without degrading sync latency?

As asked

Design the backend for a real-time messaging system similar to Microsoft Teams. It needs to support direct messages and group channels, message persistence, delivery guarantees, read receipts, and push notifications to mobile and desktop clients. Start with requirements and scale from there.

Sample answer outline

The candidate should separate the messaging write path from the read path. WebSockets or SignalR handle real-time delivery. A fan-out-on-write model works at small team scale but a fan-out-on-read model is better for large channels. Message storage needs an append-friendly store like Cassandra or CosmosDB. Push notifications require a notification service layer decoupled from the main write path. Read receipts can be handled with eventual consistency. The candidate should address what happens when a client is offline.

Expect these follow-ups

• How do you guarantee message ordering within a channel?
• How would you scale to a channel with 10,000 members?

As asked

Design the system that takes a raw video file uploaded by a content partner and makes it available for playback to 200 million subscribers worldwide with sub-second start times. Walk me through encoding, storage, CDN strategy, and the player-side adaptive bitrate logic.

Sample answer outline

A strong answer covers: transcoding into multiple resolutions and codecs (H.264, H.265, AV1) using a distributed encoding farm, chunked storage in S3 with manifests (HLS or DASH), CDN layering with Open Connect Appliances at ISPs for the last mile, and client-side ABR algorithms that switch quality based on measured bandwidth and buffer health. The candidate should discuss chunk sizing tradeoffs, CDN cache warming before a big title drop, and how DRM keys are distributed per device.

Expect these follow-ups

• How does the system decide which CDN node to direct a client to at playback start?
• Walk me through what happens from the moment a user presses play to the first video frame appearing on screen.

As asked

Notion lets multiple users edit the same page simultaneously and see each other's cursors and changes in near real-time. Walk me through how you would design this system from scratch. How do you handle conflicts when two users edit the same block at the same time, and how do you keep the document consistent without requiring a lock?

Sample answer outline

A strong answer covers the choice between operational transformation and CRDTs, explains the block-granularity model Notion uses (each block is an independent unit, so most concurrent edits are non-conflicting), and describes a server-authoritative approach where the server serializes conflicting writes and broadcasts the canonical order to all clients. The candidate should discuss optimistic local updates, rollback on conflict, and how presence data (cursors, selections) is handled as ephemeral state over a separate WebSocket channel. Bonus points for noting Notion's known migration from a monolithic Postgres approach to a more scalable sync layer.

Expect these follow-ups

• How would you handle the case where a user goes offline for 10 minutes and then reconnects with a backlog of local edits?
• Two users delete the same block simultaneously. What does the user experience look like after you resolve the conflict?

As asked

Design the backend system for a conversational AI product similar to ChatGPT. Users can have many conversations, each with many messages. The system must support real-time streaming responses, be highly available, handle millions of concurrent users, and keep costs manageable. Walk me through your architecture.

Sample answer outline

A strong answer covers: stateless API servers behind a load balancer, conversation history stored in a durable database (Postgres or DynamoDB) with a conversation ID as the partition key, streaming responses via SSE from the model inference layer through to the client, a separate inference cluster with autoscaling, async logging of prompts and responses for billing and safety review, and caching strategies for repeated system prompts. They should also address the challenge of sticky sessions for streaming connections and how to handle model timeouts gracefully.

Expect these follow-ups

• How do you handle the situation where the model inference server dies mid-stream?
• How would you implement conversation sharing, where a user can share a link to a specific conversation with someone else?

As asked

A large Shopify merchant is running a flash sale that will drive 100 times their normal traffic to checkout over a 10-minute window. Walk me through how you would design the checkout flow to handle this without data loss, overselling inventory, or cascading failures. What are the key bottlenecks and how do you address each one?

Sample answer outline

Strong answers identify the three main bottlenecks: inventory reservation races (solve with Redis Lua scripts or DB-level optimistic locking with a version counter), database write saturation (queue writes, use a separate inventory service, shard by shop), and payment provider timeouts (async payment with order status page polling). They also cover horizontal scaling of stateless checkout workers, rate-limiting per shop to prevent noisy-neighbor problems on shared infra, and circuit breakers around third-party payment gateways.

Expect these follow-ups

• How do you handle the case where a customer reserves inventory but never completes payment?
• Shopify serves many merchants on shared infrastructure. How do you prevent one merchant's flash sale from degrading other merchants?

As asked

Design the system that powers Stripe's webhook delivery. Stripe sends hundreds of millions of webhook events per day to merchant endpoints that are slow, flaky, or completely down. How would you architect reliable delivery with retry logic, ordering guarantees where needed, and observability into delivery failures?

Sample answer outline

A strong answer covers the event fan-out from the core payment processing pipeline into a durable queue per destination endpoint, a worker pool that attempts delivery with exponential backoff, a circuit breaker per endpoint to stop hammering a dead server, and dead-letter storage for events that exhaust retries. Ordering nuances matter: Stripe documents that webhooks may arrive out of order, so the candidate should explain why and how merchants should handle that. Observability should cover per-endpoint success rates, p99 delivery latency, and dashboards merchants can query.

Expect these follow-ups

• How do you prevent a single slow merchant endpoint from blocking delivery for other merchants sharing the same worker?
• A merchant reports they received the same event twice. What are the possible causes and how do you help them debug it?