Problems
Callback's own problems and the LeetCode questions companies have been asking, in one place — pick a category, then filter by company, frequency, status, difficulty, topic, and language.
System Design · Token bucket, sliding window, and where the counters live.
System Design · The classic: encoding, storage, and redirects at scale.
System Design · Fan-out on write vs. read, ranking, and the celebrity problem.
System Design · Recsys serving, not a social timeline — retrieval funnels, session state, four nines.
System Design · Fan-out, viral-pin aggregation under skew, and deciding not to send.
System Design · Tries with precomputed top-k, prefix sharding, and freshness by atomic swap.
Design an Ads Event Reporting System
System Design · Streaming for dashboards, batch for billing truth — and hot keys from viral ads.
Design a Merchant Catalog Update Pipeline
System Design · Idempotent bulk ingestion with per-item ordering, fairness, and safe deletions.
Design Image Upload and Serving for Pins
System Design · Presigned uploads, content-addressed variants, and a CDN that caches forever.
Design the Pins and Boards Data Model
System Design · Sharding a relational model: object tables, mapping tables, no cross-shard joins.
System Design · Embeddings, sharded ANN retrieval, and fresh pins searchable in seconds.
System Design · Metadata plane vs data plane, chunk replication, and the atomic-commit moment.
Move 200 TB of Media to GPU Training Hosts
System Design · Do the bandwidth arithmetic out loud, land in object storage, and never let the GPUs read small files.
Design an ML Evaluation Platform
System Design · Versioned benchmarks, cached (model, item) runs, and confidence intervals — presented as a spoken walkthrough.
Design Cloud Photo Storage and Multi-Device Sync
System Design · Bytes go straight to object storage; a per-library change feed with sync tokens is the actual product.
Design a Centralized Logging System
System Design · Agents, a durable buffer, tiered storage — and deciding how much to index before the bill decides for you.
Design Cross-Device Wallpaper Synchronization
System Design · A client-side design: apply locally at once, converge eventually, and never let sync touch the main thread.
Design the APIs for an Election Voting System
System Design · One final ballot per voter, results sealed until close — contracts, the one-transaction rule, and a recount path.
Design an Accurate Ad Click Aggregator
System Design · Dedup by impression, event-time windows with watermarks, idempotent sinks — and a batch recount that owns the truth.
System Design · Content-addressed blocks, a per-namespace journal, and conflicted copies instead of silent loss.
Design Disk-Based Inventory Serving
System Design · No SSD, little RAM: count seeks, make writes sequential, and keep the hot counters — not the metadata — in memory.
Scale Digit-Square Convergence Requests
System Design · One pass plus a 1,621-entry table makes compute free — so the design is about avoiding the network, not caching.
Design a Video Sharing Platform
System Design · A transcoding pipeline feeding a CDN: egress is the bill, so codec, ladder and cache strategy are the design.
Design a Marketplace Catalog System
System Design · Category-driven attribute schemas, products versus offers, and a search index that is always rebuildable from the source of truth.
Design and Scale a Yelp-like Reviews Platform
System Design · Geo plus text search over a read-heavy model, with review writes fanned out through queues to aggregates and the index.
Design a Smartwatch Sensor Subsystem
System Design · Heart rate on a moving wrist inside a milliwatt budget: sensor choice, a sensor hub, motion-artifact rejection, and proof it works on everyone.
Migrate a Monolithic Wallet to Microservices
System Design · Strangle the monolith in phases, keep money movement inside one ledger's transaction, and use sagas only around the outside world.
Design an Autocomplete Component (Front End)
System Design · A reusable typeahead: the component API, a data layer that debounces, cancels and caches, and the combobox pattern done properly.
Design a Music Streaming Web App (Front End)
System Design · A player that keeps playing across navigation, a queue model, streaming and preloading audio, and state shared across tabs and devices.
Design a Photo Sharing App (Front End)
System Design · An infinite feed of images without layout shift, optimistic likes, and an upload flow that resizes, strips location and survives a bad connection.
Design a Distributed Job Scheduler
System Design · A job store as the source of truth, dispatchers that claim due runs with a unique key, leased workers, and a reaper — then the policies a template answer forgets.
Design a Distributed Key-Value Store
System Design · Non-functional requirements first, then one real decision per layer — and the large-value variant, where the lock must never cover the disk write.
System Design · A durable source of truth for grants, a cache of compiled decisions on the caller's hot path, and a closed fail mode.
System Design · Start from a Queue class, then make every step survive a client, server or network failure in the middle of it.
Design a Control Plane for Cloud Clusters
System Design · Desired state in a consistent store, controllers that reconcile, heartbeating agents, and a failure detector that fences before it replaces.
System Design · Append-only events partitioned by account then time, a hot store for recent queries, object storage for retention, and tamper evidence per account.
Design a Pipeline From Bug Tickets to Generated Pull Requests
System Design · A ticket becomes a row with a state machine, a queue feeds long-running workers, and every step is idempotent because the AI step will be retried.
Design an RPC Layer Over Hand-Written REST Calls
System Design · An interface definition that generates stubs and skeletons, with marshalling, discovery, deadlines, idempotent retries and versioning handled once.
Design a Logging Library for Web and Mobile Clients
System Design · A non-blocking log() into a bounded buffer, flushed by size or time, persisted offline, with a stated policy for what to drop under pressure.
Design a Client for an Unreliable Token Service
System Design · Cache tokens with expiry, refresh ahead of time with jitter, single-flight the refresh, and decide between a slightly stale token and a failed request.
Design a Global Multi-Tenant Quota System
System Design · One usage record per tenant across every service, reserve-then-commit, idempotent usage events, and a chosen point between strict consistency and latency.
Design a Distributed Metrics System
System Design · Agents batch to an ingest tier, a time-series store partitioned by metric and time, downsampling for age — and a hard line on cardinality.
System Design · A frontier of URLs partitioned by host, fetchers that respect per-host limits, dedup by URL and by content, and failure handling that never stalls the crawl.
Count the Nodes in a Tree of Servers
System Design · A request fans down the tree and counts fan back up; messages can be lost or duplicated, so every message carries an id and every handler is idempotent.
System Design · Prepare on all participants, then commit; it blocks if the coordinator dies after prepare.
System Design · A leader replicates a log to a majority before committing; a new leader is elected by majority vote.
Design an Interactive SQL Notebook or Query Execution Service
System Design · A query is a record with a state machine: submit returns an id at once, workers stream results to storage, and clients fetch by id, never by connection.
Design a Multi-Tenant Interactive Analytics Platform
System Design · Immutable columnar files in object storage, a transactional metadata service that commits snapshots, and stateless compute that scales per tenant.
Design a Metadata Catalog and Schema Registry
System Design · Versioned entities in a consistent store partitioned by tenant, a per-tenant change log that caches subscribe to, and soft deletes for undrop.
Design a Cache for a DAG of Materialized Views
System Design · Key every entry by the view, its definition hash and the snapshot versions of all its inputs, so a changed input is a new key and nothing needs explicit invalidation.
Design a Multi-Core Service Startup Scheduler
System Design · Kahn's algorithm with a ready queue and M running slots, where a service unblocks its dependants only after its health check passes and the longest remaining chain goes first.
Design a Multi-Region API Whose Clients Need Tokens From a Flaky Third Party
System Design · Cache what the provider would tell you — signing keys, introspection results, permissions — so a provider outage degrades the API instead of taking it down.