01
Build
Click or drag provider-neutral components onto the canvas. Connect them, move private services into real boundaries, and keep the interaction fast without edge-type dialogs.
Open beta
System Design Studio
Do not just draw a system.
Prove the design holds together.
Build architectures on an interactive canvas. Katabench checks the paths, boundaries, and redundancy that should be there, plus the dangerous bypasses that should not, then teaches you the tradeoffs behind the passing design.
6 free with an account 59 beta challenges Best on desktop
- 59
- progressive challenges
- 28
- provider-neutral components
- Easy to Hard
- one pressure at a time
The practice loop
Build. Check. Learn.
A system design prompt becomes deliberate practice when the diagram has a clear goal, immediate evidence, and a useful debrief.
02
Check
Get deterministic feedback on required paths, forbidden bypasses, redundancy, fan-out, containment, and connection semantics, plus a capacity report under modeled traffic. Failed rules come first.
03
Learn
Use progressive hints when you need them. A passing Submit opens the tradeoffs, failure modes, and operational signals behind the accepted design.
The difference
A diagram that has to mean something
Katabench understands what the boxes represent. It can reject a direct client-to-database route, an app path that skips the cache, a queue without redundant consumers, or a service drawn inside a VNet without actually belonging to it.
Feedback is deterministic and grouped by correctness, security, reliability, performance, and observability. No aesthetic score. No black-box AI verdict.
Guided curriculum
Learn the primitives. Then build the product.
Nine fundamentals each pair one requirement with the pattern that solves it. Seven build courses then carry one product each, from a video platform and a URL shortener to a reliable checkout and a social feed, through the decisions that appear as its traffic and responsibilities grow.
Series 01 · Fundamentals
One requirement, one canonical pattern
Each challenge states a problem and applies the building block that solves it: a trusted boundary, a highly available API, caching, queues, database failover, an edge, rate limiting, sharding, and search.
9 challenges
- 01
Keep clients off the database
Route Through the App
Free EasyPut a trusted service between the client and the data so nothing queries the database directly.
3 deterministic checks
- 02
Survive an instance failure
Scale the Web Tier
Free EasyLoad-balance redundant, stateless instances so the balancer reroutes around a failed one.
9 deterministic checks
- 03
Serve reads at scale
Cache the Hot Path
Free MediumAdd cache-aside in front of the database and a standby replica behind it.
12 deterministic checks
- 04
Survive a database failure
Survive a Database Failure
MediumStream changes to a promotable standby replica so a lost primary is not a lost product.
8 deterministic checks
- 05
Cut global latency
Serve from the Edge
MediumCache static content at a global edge and keep the origin for what actually changes.
9 deterministic checks
- 06
Shed abusive traffic
Rate-Limit at the Gateway
MediumCount requests at the gateway against a shared store and reject overload before it reaches the app.
12 deterministic checks
- 07
Make it searchable
Derive a Search Index
MediumProject committed changes from the source database into a derived search index that queries read.
12 deterministic checks
- 08
Absorb a write spike
Buffer the Write Spike
HardDecouple arrival from processing with a durable queue and a redundant worker pool.
16 deterministic checks
- 09
Scale past one database
Shard the Database
HardPartition the data across shards and route each key to the shard that owns it.
7 deterministic checks
Series 02 · Build a Video Platform
Evolve one product from catalog to operations
Carry the same video product through catalog scale, edge delivery, uploads, search, security, and observability.
8 challenges
- 10
Split metadata from media
Build a Video Catalog
EasyMetadata in a database, video bytes in object storage, and one trusted Catalog API owning both stores.
7 deterministic checks
- 11
Remove the single API failure
Scale the Video Catalog
EasyPut a load balancer in front of interchangeable Catalog API instances that all share both stores.
10 deterministic checks
- 12
Relieve repeated metadata reads
Cache the Video Watch Page
MediumCache the hot watch-page rows while video bytes keep their own uncached path to storage.
11 deterministic checks
- 13
Separate control from media delivery
Deliver Video from the Edge
MediumKeep playback authorization behind an API while a CDN serves video from durable object storage.
9 deterministic checks
- 14
Move long work off the request path
Process Video Uploads
MediumUse signed object uploads, durable messaging, and redundant workers to absorb processing bursts.
13 deterministic checks
- 15
Create a searchable projection
Build Video Search
MediumKeep the metadata database authoritative while committed changes update search asynchronously.
14 deterministic checks
- 16
Lock down the master files
Secure Video Operations
HardLock the origin bucket in a private subnet, sign every upload from the vault, and make the CDN the only read path.
14 deterministic checks
- 17
Explain asynchronous delays
Observe the Video Pipeline
HardCollect broker and worker telemetry through OpenTelemetry, with operators reaching Grafana only over a VPN.
16 deterministic checks
Series 03 · Build a URL Shortener
Scale one tiny request a billion times
Carry a link shortener from its first trusted boundary to cached redirects, asynchronous click analytics, edge delivery, and full observability.
6 challenges
- 18
Own the data and the codes
Shorten the First Link
EasyPut a Link API in front of the links table and lease collision-free code blocks from a Key Issuer.
7 deterministic checks
- 19
Outlive one link's spike
Survive the Viral Link
EasySplit the redirect hot path from the create path and scale only the tier that is on fire.
11 deterministic checks
- 20
Stop re-reading the same row
Cache the Redirect
MediumCache the read path only (writes go around it) and weigh 301 against 302 before browsers decide for you.
12 deterministic checks
- 21
Measure without slowing down
Count the Clicks
MediumQueue click events off the redirect path and land them in a dedicated Click Store, never the links table.
16 deterministic checks
- 22
Beat the speed of distance
Redirect from the Edge
MediumServe hot redirects from a global edge with TTLs that keep deletion and analytics honest.
10 deterministic checks
- 23
Prove where the time goes
Observe the Shortener
HardTrace every tier through OpenTelemetry, and keep the dashboards behind an operator VPN; the system is public, the view into it is not.
20 deterministic checks
Series 04 · Build a File Vault
Move heavy bytes without melting the API
Store, scan, and share user files with signed uploads, an event-driven malware scan, edge downloads, and a guarded admin plane.
5 challenges
- 24
Get bytes out of the database
Store the First File
EasySplit immutable file bytes into object storage while the database keeps the metadata it can query.
5 deterministic checks
- 25
Free the request workers
Upload Directly to Storage
MediumAuthorize at the API, then move gigabytes with short-lived signed uploads that bypass it.
8 deterministic checks
- 26
Never share unscanned bytes
Scan Before You Share
MediumTurn object-created events into redundant malware scans that gate sharing on a recorded verdict.
14 deterministic checks
- 27
Stop proxying downloads
Download from the Edge
MediumLet the Share API decide who may download while the edge network moves the bytes.
10 deterministic checks
- 28
Shrink the blast radius
Guard the Vault
HardPut the admin plane, metadata, and signing keys behind a VPN inside real network boundaries.
15 deterministic checks
Series 05 · Build a Notification Platform
Deliver at scale without ignoring consent
Move from trusted acceptance to asynchronous channel fan-out, preference enforcement, provider isolation, and delivery operations.
5 challenges
- 29
Fail at intake, not at send time
Accept Notification Requests
EasyLet a Notification API resolve every campaign's template at intake and durably accept the request.
8 deterministic checks
- 30
Isolate provider latency
Queue Notification Delivery
MediumAcknowledge accepted work, then deliver through a durable asynchronous queue.
9 deterministic checks
- 31
Scale email, SMS, and push independently
Fan Out Notification Channels
MediumPublish once to a topic and give each channel an isolated consumer path.
9 deterministic checks
- 32
Apply opt-outs under campaign load
Honor Notification Preferences
HardPut a shared preference cache backed by durable truth on every delivery path.
12 deterministic checks
- 33
Make delivery diagnosable and resilient
Operate the Notification Platform
HardCombine redundant compute, managed provider secrets, and telemetry across asynchronous channels.
20 deterministic checks
Series 06 · Build Real-time Chat
Keep millions of conversations connected
Scale long-lived connections, durable ordered messages, presence, attachments, secrets, and asynchronous observability.
5 challenges
- 34
Secure the real-time boundary
Establish a Chat Session
EasyTerminate untrusted connections at a gateway and keep conversation policy in a Chat Service.
6 deterministic checks
- 35
Survive a connection-host deploy
Scale Real-time Connections
MediumLoad-balance interchangeable gateways and move presence into shared leased state.
7 deterministic checks
- 36
Keep storage latency off socket loops
Persist Chat Messages
MediumPublish accepted messages durably and persist them with redundant ordered consumers.
11 deterministic checks
- 37
Keep media bytes off connection hosts
Deliver Chat Attachments
MediumAuthorize through the API, upload directly with a signed grant, and read from the edge.
10 deterministic checks
- 38
Trace sockets through durable delivery
Operate the Real-time Chat Platform
HardUnify connection scale, persistence, media, secrets, and cross-broker observability.
18 deterministic checks
Series 07 · Build a Reliable Checkout
Move money through explicit failure states
Practice inventory reservation, idempotent payment, transactional outbox delivery, compensation boundaries, and reconciliation signals.
5 challenges
- 39
Stop trusting browser totals
Own the Checkout Command
EasyReprice every cart from the Product Catalog behind one trusted Checkout API; a browser's total is a claim.
9 deterministic checks
- 40
Avoid charging unavailable stock
Reserve Before Payment
MediumCommit a bounded inventory reservation before payment enters the asynchronous path.
10 deterministic checks
- 41
Make redelivery safe for money movement
Make Payment Idempotent
MediumGive every payment worker the same durable idempotency ledger and provider key.
10 deterministic checks
- 42
Close the database-to-broker loss window
Publish Order Events Reliably
HardRelay a transactional outbox into independent fulfillment and receipt subscriptions.
10 deterministic checks
- 43
Explain every pending order
Operate the Reliable Checkout
HardCombine redundant checkout, idempotent payment, outbox delivery, secrets, and stage-level telemetry.
23 deterministic checks
Series 08 · Build a Social Feed
Balance write fan-out against read-time work
Build materialized timelines, a celebrity hybrid, moderation and search projections, edge media, and freshness operations.
5 challenges
- 44
Own identity and visibility
Publish the First Post
Free EasyKeep publishing behind a trusted Post API, with content in the Post Store and follows in their own Social Graph.
9 deterministic checks
- 45
Stop recomputing every feed read
Fan Out Home Timelines
Free MediumProject post events into replayable follower timelines, with workers expanding audiences from the Social Graph.
13 deterministic checks
- 46
Cap worst-case write amplification
Handle Celebrity Fan-out
Free HardRoute each publish by its Social Graph follower count: push timelines for ordinary authors, pull-time candidates for celebrities.
18 deterministic checks
- 47
Derive policy and search without API dual writes
Moderate and Index Posts
HardBuild replayable moderation and search projections from committed content events.
14 deterministic checks
- 48
Operate every eventually consistent view
Operate the Social Feed
HardBring hybrid feeds, search, edge media, managed secrets, and freshness telemetry together.
31 deterministic checks
Series 09 · Build a Distributed Web Crawler
Turn the open web into a polite, fresh corpus
Build durable frontier scheduling, host ownership, private-region VPN transport, two-stage deduplication, incremental recrawling, search indexing, and full pipeline operations.
10 challenges
- 49
Make crawl progress durable
Start the URL Frontier
EasySeparate accepted seed URLs, pending work, network fetching, and completed page bytes.
11 deterministic checks
- 50
Retry parsing without refetching
Checkpoint Before Parsing
MediumCheckpoint raw bytes and hand parsing off through a second durable queue.
11 deterministic checks
- 51
Stop cycles from exploding the frontier
Deduplicate Discovered URLs
MediumCanonicalize and atomically claim every URL in one shared admission ledger.
9 deterministic checks
- 52
Share expensive control decisions
Cache DNS and Robots Rules
MediumGive every fetcher shared DNS and robots cache-aside paths with no private bypass.
9 deterministic checks
- 53
Stay fast without attacking one origin
Schedule Hosts Politely
HardSeparate global priority from host eligibility with shared leases and a ready-host queue.
10 deterministic checks
- 54
Scale ownership into an isolated worker region
Partition Crawl Ownership
HardHash hosts across durable frontier shards, then cross a bidirectional site-to-site VPN without bypass paths.
32 deterministic checks
- 55
Stop mirrors from multiplying downstream work
Deduplicate Page Content
HardClaim content digests after fetching but before expensive parsing and indexing.
10 deterministic checks
- 56
Keep a changing web repository fresh
Recrawl for Freshness
HardSchedule revisits from durable history and update that history only from observed versions.
13 deterministic checks
- 57
Serve search without coupling it to crawling
Index the Crawled Web
HardBuild a replayable index projection and an independently redundant query plane.
17 deterministic checks
- 58
Explain one page across the whole crawl
Operate the Web Crawler
HardCombine private-region VPN transport, ownership, politeness, checkpoints, identity, quarantine, indexing, and telemetry.
65 deterministic checks
Optional synthesis
Operate the complete upload pipeline
Bring networking, storage, messaging, secrets, and observability together after the focused lessons.
1 challenge
- 59
Synthesize the whole operating model
Operate the Upload Pipeline
Optional capstone HardCombine signed uploads, messaging, private boundaries, secrets, OpenTelemetry, and Grafana.
34 deterministic checks
Standard component vocabulary
28 components. One visual language.
Design with capabilities, not one cloud vendor's catalog. Every lesson exposes only the choices that matter, while the shapes and meanings stay consistent across the curriculum.
Edge & network
- Client
- IoT Device
- External System
- CDN
- Load Balancer
- API Gateway
- Edge Gateway
- VPN Gateway
- Virtual Network
- Subnet
Compute
- App Service
- Worker
- Serverless
Messaging
- Queue
- Message Broker
- Topic
- Event Bus
Data & storage
- Cache
- Database
- DB Replica
- Search
- Object Storage
- Shared File Storage
Security & operations
- Secrets Vault
- Identity Provider
- OTel Collector
- Grafana
- Grafana Stack
The learning payoff
Passing is the start of the debrief
A clean Submit opens a puzzle-owned lesson explaining why the topology works, where it can fail, which signals matter in production, and which properties a diagram cannot establish.
In Cache the Hot Path, for example, the lesson moves beyond adding a cache into hit-rate math, cache-aside behavior, invalidation, stampedes, failure policy, and replica lag.
Honest grading boundary
A structural verdict, and the numbers beside it
The pass verdict comes from the deterministic rubric. Alongside it, a capacity simulation with versioned scenarios and fixed seeds shows how the topology behaves under modeled traffic, so the same design always produces the same report.
The rubric verifies
- Required components and end-to-end semantic paths
- Forbidden direct connections and bypass routes
- Fan-out, participation, and structural redundancy
- Real VNet and subnet containment
- Request, messaging, storage, secrets, telemetry, and replication semantics
The simulation reports
- p99 latency, throughput, and error rate under versioned traffic scenarios
- The component that saturates first, and why it became the bottleneck
- SLO targets beside what the design actually achieved
- A modeled monthly cost for the topology
The report is a reproducible model built for learning, not a provisioned load test. Behavioral correctness, such as whether failover actually promotes or authorization actually denies, stays beyond any diagram's reach; real measured load belongs in calibrated labs.
Frequently asked questions
Is this an AI architecture review?
No. The rules are authored and deterministic. The same valid topology receives the same verdict, and feedback names the exact property that passed or failed.
Does a passing design prove it scales in production?
The verdict grades structural properties, and a deterministic capacity simulation reports p99 latency, throughput, error rate, and modeled cost under versioned traffic scenarios, naming the component that saturates first. Those numbers are a reproducible model built for learning, not a provisioned load test.
Do I need AWS, Azure, or GCP experience?
No. Components are provider-neutral capabilities such as load balancer, queue, object storage, secrets vault, and OpenTelemetry collector. The lessons teach the decision before the vendor product.
Is there only one correct diagram?
No. Rules grade properties such as safe paths, containment, redundancy, and forbidden bypasses. They do not compare pixels or require one exact layout.
How many challenges are in the beta?
Fifty-nine. Nine fundamentals isolate the core patterns, then eight progressive build courses apply them to video, URL shortening, file storage, notifications, real-time chat, checkout, social feeds, and a distributed web crawler. One optional hard capstone combines the operating concerns.
Can I build a design on my phone?
Yes. The Studio has a touch layout with a bottom-sheet inspector, and signed-in drafts sync across devices, so a topology started on a phone is waiting on the desktop. Deliberate authoring is still best on a desktop or laptop, where dragging, connecting, and inspecting stay precise.
What does it cost?
You can start building and editing in the browser without an account. Sign in to check and submit; six challenges are included with a free account, including an Easy-to-Hard Social Feed mini-course. The rest of the catalog is part of Katabench Pro.
Want the reasoning before the canvas? The system design guides walk through load balancing, replication, sharding, queues, edge caching, and capacity estimation with the same failure-first framing the challenges use.
Build the smallest safe system
Start with three components and one rule that matters: the client never touches the database. 6 challenges are free on every account, including an Easy-to-Hard Social Feed mini-course; Katabench Pro opens the complete curriculum across eight product domains and the synthesis capstone.
Solve Route Through the App