Challenges

Real-World Systems

44 challenges44 playable now

Topic

Difficulty

Showing 44 of 44

Build a Key-Value Store

Build your own Redis-style in-memory key-value store. You'll start with a dict-backed store, add TTL expiry, expose an HTTP API, and end with a pluggable backend via the Strategy pattern.

~45 minStart

intermediate

WAL & Snapshots

Make your KV store survive restarts. Implement a write-ahead log, replay it to rebuild state, snapshot the dataset to compact the log, and recover cleanly even after a crash mid-write.

~60 minStart

intermediate

TTL & Active Expiry

Expire keys proactively. Build lazy expiry on read, then a Redis-style active sweeper that randomly samples keys with a TTL — instead of a timer per key — and bound its work so it never blocks.

~50 minStart

intermediateFree

Rate Limiter

Implement the classic rate-limiting algorithms — fixed window, sliding-window log, sliding-window counter, and token bucket — see where each breaks under bursty traffic, then key them per client.

~60 minStart

intermediate

Circuit Breaker

Stop hammering a failing dependency. Build the Closed → Open → Half-Open state machine that trips after repeated failures, fails fast while open, probes for recovery after a timeout, and wraps calls end to end.

~55 minStart

intermediate

Thread Pool

Build a worker pool that runs queued jobs and returns results through futures. Handle exceptions per job, add a map() convenience, and distribute work across N workers round-robin.

~55 minStart

intermediate

HTTP Web Server

Build a web server from the request line up: parse raw HTTP requests, serialize responses, route by method and path, extract path parameters, and run a middleware chain — all without touching a socket.

~60 minStart

intermediate

Object Store

Build an S3-style object store: buckets holding keyed objects with put/get/delete, strict bucket semantics, prefix listing, per-object metadata and content types, and delimiter-based folder listing.

~55 minStart

intermediate

API Rate Limiter

The applied, gateway side of rate limiting: per-client quotas that return rich results, standard X-RateLimit headers, per-endpoint limits, tiered plans, and a 429-emitting middleware.

~55 minStart

intermediate

DNS Resolver

Resolve names to addresses: look up A records, follow CNAME chains (with loop protection), round-robin multiple addresses, cache answers by their TTL, and negatively cache misses.

~55 minStart

intermediate

curl (HTTP Client)

Build your own curl: parse a URL into its parts, serialize an HTTP request, parse the response, drive it all through a pluggable transport, and follow redirects — the client side of the web server you built.

~55 minStart

intermediate

CDN (Content Delivery Network)

Cache content at the edge: serve origin responses from a TTL cache, track hit/miss ratios, purge stale entries, honor no-store, and route each client to its own regional edge (point of presence).

~55 minStart

intermediate

Message Queue

Build the broker behind async systems: FIFO enqueue/dequeue, acknowledgements with in-flight tracking, visibility-timeout redelivery for at-least-once delivery, a dead-letter queue for poison messages, and pub/sub topic fan-out.

~60 minStart

intermediate

Pub/Sub Broker

Build the messaging backbone behind event-driven systems: callback subscriptions with clean unsubscribe, MQTT-style wildcard topic matching, retained messages so late subscribers catch up, an append-only log with offsets, and durable consumers that commit their position for at-least-once delivery.

~55 minStart

intermediate

URL Shortener

Build a bit.ly from the ground up: Base62 encoding to turn ids into short codes, an auto-incrementing shortener with expand, custom aliases with collision handling, a Snowflake-style distributed id generator, and click analytics with link expiry.

~45 minStart

intermediate

JSON Web Tokens (JWT)

Build the stateless auth token that backs modern APIs: base64url encoding, the header.payload signing input, an HMAC-SHA256 signature, verification with a constant-time compare, and expiry (exp) enforcement — so you understand exactly what a JWT is and why a tampered one fails.

~50 minStart

intermediate

Role-Based Access Control

Build the authorization engine behind every admin panel: roles that grant permissions, users assigned roles, role inheritance so an admin gets an editor's rights, wildcard permissions like `doc:*`, and explicit per-user denies that override everything.

~45 minStart

intermediate

Idempotency Keys

Make retries safe. Build the mechanism that stops a double-clicked 'Pay' button from charging twice: cache a response by its idempotency key and replay it, reject a key reused with a different request, expire keys after a TTL, and scope keys per user so they never collide.

~40 minStart

intermediate

Lamport Clocks

Order events across machines with no synchronized wall clock. Build Lamport's logical clock — a counter that ticks on every local event, rides along on every message, and jumps forward on receipt — then use it to impose a consistent total order over a distributed system. The foundation of causality tracking behind vector clocks, version vectors, and distributed databases.

~45 minStart

intermediate

Server-Sent Events (SSE)

Push updates to a browser over one long-lived HTTP response — no WebSocket handshake required. Implement the text/event-stream wire format: serialize events with data, event, and id fields, then parse a raw stream back into structured events, handling multi-line payloads, comments, and reconnection ids. The transport behind live dashboards, notifications, and token-by-token AI streaming.

~45 minStart

intermediate

Webhook Dispatcher

Deliver events to other people's servers reliably, even when they're flaky. Build the pieces every webhook system needs: an HMAC signature so receivers can trust the payload, an exponential-backoff retry schedule, a dispatcher that retries failed deliveries, and idempotent dispatch so a redelivery never fires the same event twice. The machinery behind Stripe, GitHub, and Slack webhooks.

~50 minStart

intermediate

Saga Orchestrator

Coordinate a multi-service transaction without a distributed lock. A saga runs a sequence of local steps, each paired with a compensating action that undoes it. If any step fails, the orchestrator rolls the world back by running the compensations for the completed steps in reverse order. Build the step registry, the forward run, and the reverse compensation — the pattern behind order/payment/shipping workflows in microservices.

~50 minStart

intermediate

Transactional Outbox

Never lose an event, never write a lie. The outbox pattern solves the dual-write problem: instead of writing to your database and then publishing to a message broker (two systems that can disagree when one fails), you write the business row and the event to the same database in one transaction, then a relay ships the events out. Build the atomic write, the polling relay, and an idempotent consumer that makes at-least-once delivery safe.

~50 minStart

intermediate

Gossip Protocol

Spread state across a cluster with no coordinator — the way rumors spread through a crowd. Each node holds versioned key/value state; when two nodes gossip they exchange updates and keep the higher version of every key. Build the versioned store, the anti-entropy merge, a bidirectional gossip exchange, and prove the whole cluster converges. The dissemination layer inside Cassandra, DynamoDB, and Consul.

~45 minStart

intermediate

Event Sourcing

Stop storing state — store the events that produced it. Instead of overwriting a row, you append an immutable log of what happened and derive current state by replaying it. Build the append-only event store, the fold that rebuilds state, snapshots to skip replaying from the beginning, and time-travel to any past version. The pattern behind ledgers, audit logs, and Git itself.

~50 minStart

intermediate

Service Registry

Let services find each other in a fleet where instances come and go. A registry tracks which instances of each service are alive, expires ones that stop sending heartbeats, and hands callers a healthy instance to talk to. Build registration, heartbeat-based TTL expiry, health-filtered discovery, and round-robin load balancing — the service-discovery core of Consul, Eureka, and etcd.

~45 minStart

intermediate

MapReduce

Process a dataset too big for one machine by splitting the work into two simple functions. Map turns each input into key/value pairs; the framework shuffles pairs together by key; reduce collapses each key's values into a result. Build the three phases, wire them into a word-count job, and add a combiner that pre-aggregates locally — the programming model that powered Google's index and inspired Hadoop and Spark.

~50 minStart

intermediate

Distributed Tracing

Follow a single request as it fans out across dozens of services. A trace is a tree of timed spans — one per operation — linked by parent/child ids and sharing a trace id. Build the span with its duration, a tracer that propagates context to child spans, the reassembly of a flat span list into its trace tree, and the analysis that finds total latency and the slowest operation. The model behind Jaeger, Zipkin, and OpenTelemetry.

~50 minStart

advanced

Build an Event Loop

Write your own tiny asyncio-style event loop from scratch: a ready queue, generator-based coroutines that cooperate with yield, a virtual clock for sleep, and gather to run coroutines concurrently.

~75 minStart

advanced

Load Balancer

Build a load balancer from round-robin to least-connections, add health checks, eject failing backends automatically, and make the selection strategy pluggable — handling node failure gracefully throughout.

~75 minStart

advanced

LSM-Tree & SSTables

Build the storage engine behind modern databases: an in-memory memtable that flushes to immutable sorted string tables, reads that merge newest-first across levels, tombstone deletes, and compaction.

~70 minStart

advanced

Reverse Proxy

Sit in front of your backends: route requests by path prefix, rewrite paths, load-balance across an upstream pool, add forwarding headers, and fail over around unhealthy backends.

~60 minStart

advanced

API Gateway

The capstone of the web-infra family: a single front door that routes requests to backend services by prefix, forwards them through a pluggable transport, runs a middleware pipeline (onion model), enforces API-key auth, and fans out to aggregate several services into one response.

~65 minStart

advanced

Database Replication

Keep copies of your data in sync: write through a primary and a replication log, apply it to a replica, reason about replication lag, guarantee read-your-writes, and fail over by promoting a replica — losing the writes that never replicated.

~60 minStart

advanced

Database Sharding

Split data across many nodes: route keys to shards with a deterministic hash, store and fetch from the right shard, scatter-gather across all shards, shard by key range instead of hash, and reshard by rehashing every key when you add a node.

~60 minStart

advanced

Distributed Lock

Build the coordination primitive behind leader election and exclusive access: mutual exclusion with owner tokens, self-expiring leases so a crashed holder can't deadlock the system, monotonic fencing tokens that stop stale writers, lease renewal for long jobs, and a Redlock-style quorum across N nodes.

~60 minStart

advanced

CRDTs (Conflict-Free Replicated Data Types)

Let two replicas edit the same data offline and merge with no coordination and no conflicts. Build the four canonical state-based CRDTs — a grow-only counter, a PN-counter, a last-writer-wins register, and an add-wins OR-Set — each with a commutative, associative, idempotent merge. The math behind Redis CRDTs, Riak, and collaborative editors.

~60 minStart

advanced

WebSocket Framing

Turn a raw byte stream into real-time messages. Implement the RFC 6455 wire format: pack the FIN bit and opcode, encode payload length across its three regimes, apply the client masking XOR, then decode a frame back into a message. The framing layer under every live chat, trading feed, and collaborative editor.

~60 minStart

advanced

Two-Phase Commit (2PC)

Make several databases agree to commit — or none of them do. Implement the classic atomic-commit protocol: participants vote in a prepare phase, a coordinator decides commit only if every vote is yes, and the decision is driven home in a second phase. Build the voting participant, the coordinator's all-or-nothing rule, the full protocol, and the abort path. The consensus behind distributed transactions in Postgres XA, MySQL, and sharded stores.

~55 minStart

advanced

Raft — Leader Election

Elect a single leader in a cluster where nodes crash and messages drop — the heart of the Raft consensus algorithm. Implement the election: a node bumps its term and becomes a candidate, peers grant at most one vote per term, a candidate that wins a majority becomes leader, and any node that sees a newer term immediately steps down. The mechanism that keeps etcd, Consul, and CockroachDB consistent.

~60 minStart

advanced

Operational Transformation

Let two people edit the same document at the same time and still end up with identical text. Operational Transformation is the algorithm behind Google Docs: represent edits as insert/delete operations, then transform a concurrent operation against another so that applying them in either order converges. Build apply, the four transform cases, and prove the convergence property that makes real-time collaboration possible.

~60 minStart

advanced

CQRS (Command Query Responsibility Segregation)

Split the model that changes data from the models that read it. In CQRS, commands go through a write model that validates and emits events, while queries are served by separate read projections shaped for exactly how they're viewed. Build the write model that decides and applies events, denormalized read projections, and the command bus that wires them together — the architecture that lets reads and writes scale independently.

~55 minStart

advanced

Stream Windowing

Turn an endless stream of events into finite chunks you can aggregate. Windowing is how stream processors compute things like 'requests per minute' over data that never ends. Build the three canonical window types: tumbling (fixed, non-overlapping), sliding (overlapping), and session (gap-based), plus the per-window aggregation. The bucketing logic inside Flink, Kafka Streams, and Spark Structured Streaming.

~55 minStart

advanced

Reliable Transport

Build reliable delivery on top of an unreliable network — the problem TCP solves. Packets get lost, duplicated, and reordered; the transport layer hides all of it. Implement sequence numbers, a receiver that reassembles in order with cumulative acknowledgements, a sender that tracks what's been acked, and a sliding window with retransmission. The machinery that turns a lossy channel into an ordered, gap-free byte stream.

~60 minStart