The work senior engineers
actually do.Practice it.
Production-style backend labs you run in your browser. Debug a p99 regression with pg_stat_statements. Stop a retry storm. Find a goroutine leak in pprof. Real Postgres, real Redis, real microVMs — graded on latency and memory, not just “did it pass.”
Checkout p99: 80ms → 2.3s
Cache TTL expired this morning and the dashboard lit up. Find the N+1 hiding behind a hot endpoint, batch the query, and get p99 back under target.
Requirements
- Issue at most 3 DB queries per Checkout.
- Survive 30 concurrent checkouts.
- Don't hold a global lock.
- 07:14 deploy went out
- 07:21 cache TTL expired
- 07:22 p99 1.8s
- 07:25 dashboards red
query calls mean_ms ───────────── ────── ────── SELECT price … 47 38.2 INSERT cart … 1 4.1
// trusted by engineers at
// what you'll touch
The artifacts of real engineering.
Every lab gives you the same things a senior engineer uses on a tough day: flamegraphs, metrics, logs, code. Not a textarea.
Flamegraphs that point at the slow path.
// hot path func Checkout(w, r) { for _, item := range cart.Items { price, _ := db.Query( "SELECT ...", item.ID) } }
A real editor against a running service.
Before/after latency against the target.
Logs you actually read to find the bug.
// the gap
Most engineers don't know where their real gap is.
The interview prep industry has trained a whole generation to measure themselves on the wrong axes. We map the right ones — and close them.
Where most prep stops
Algorithm puzzles. Two-pointer tricks. Memorized patterns that disappear within weeks of the interview.
Where the job actually lives
Reading traces. Reasoning about latency. Surviving 3am incidents. The Cracked SWE pathway targets every one.
Your engineering skill, by axis
Five engineering axes that decide whether you survive an incident. The labs close the gap one artifact at a time.
// anatomy of a debug lab
You don't read about a bug. You hunt it.
Open the lab. A real environment boots in seconds.
Your sandbox spins up a Linux microVM running a broken backend service, a Postgres with 5M rows, a Redis cache, a load generator hammering the API, and a Grafana-style dashboard. All in your browser.
[boot] sandbox.create
[boot] postgres starting
[boot] redis starting
[boot] loadgen warming up
[ready] 3.2s
Read the brief. Diagnose with real artifacts.
Logs scroll past. The metrics panel shows a p99 spike correlated with a deploy. Traces let you click into a single slow request and see the flame. There is no tutorial nudging you — there are signals, like in real life.
Edit code. Hit Cmd+Enter. Watch the system heal.
Edits sync to the sandbox in real time. Run the load generator, watch p99 drop on the dashboard. Submit when you're confident — or experiment freely.
Get scored on more than "did it pass."
Correctness is the gate. Then your benchmark runs and we measure it against the lab's baseline and world-class target — so you see whether your fix is fast enough, not just whether it compiles.
// the AI tutor that doesn't cheat
Lab-tuned tutor.
Hints, not spoilers.
The in-lab tutor reads your code, sees your failing tests, and walks you up a five-rung hint ladder when you're stuck. Trained to refuse the solution — even if you ask.
Knows the lab
System prompt is tuned per lab — brief, relevant concepts, your current editor buffer, your last run output. Not generic ChatGPT.
Hint ladder, not handouts
Starts with a concept question. Climbs only when you push. Caps at a small snippet — never the full solution.
Never sees the answer key
The grader source and reference solution are hard-excluded from context. The tutor can't leak what it can't see.
// assistant
Lab tutor
you
checkout endpoint p99 hit 2.3s. what's going on?
assistant
Open the test logs — how many DB queries fire per checkout? Then check validateInventory: what does it do for each cart item?
you
one query per item. so 50 queries for a 50-item cart
assistant
Exactly — one DB round-trip per item. That's your p99. Fetch all the inventory you need in one query instead of N.
N+1 queries
The hidden latency multiplier in request-time database access.
// practice across the stack
Master every layer that breaks in production.
One pathway. Twelve labs. Every layer of the backend stack — the same surfaces that page senior engineers at 2am.
HTTP · Sockets to status codes.
Build a real HTTP server
Sockets, request parsing, routing. No net/http allowed.
GET /checkout HTTP/1.1 Host: Cracked SWE User-Agent: lab-runner Connection: keep-alive 200 OK · 187ms · 1.2kb
// cracked knowledge
The questions a senior backend interview actually asks.
226 questions across 7 domains and 33 topics — scenarios, code reviews, and concept checks, each graded with a real explanation. Not a single brain-teaser.
01Networking & HTTP
52 QTCP · IP & Addressing · UDP · Flow & Congestion Control · HTTP Protocol · TLS & DNS
02Concurrency
36 QData Races & Memory Model · Mutexes & Locking · Atomics & Lock-Free · Channels & Coordination · Goroutine Lifecycle & Leaks · Backpressure & Pools
03Caching & Redis
33 QCache Fundamentals · Stampede & Cold Start · TTLs & Expiration · Redis Data Structures · Write Strategies & Consistency
04Databases & Transactions
28 QQuery Performance · Indexes & Plans · Transactions & Isolation · Concurrency Control
05Queues & Streams
24 QDelivery Semantics · Consumer Groups & Offsets · Idempotency & Dedup · Retries, DLQ & Poison
06Reliability
29 QRate Limiting · Retries & Backoff · Circuit Breakers · Timeouts, Bulkheads & Load Shedding
07Observability
24 QProfiling · Leak Detection · Metrics & SLOs · Incident Debugging
// try one, no signup
A real question, graded live.
Pick an answer and we'll grade it the same way the app does — then show you why.
Databases & Transactions · Transactions & Isolation
CrackedTwo on-call doctors each read 'at least one other doctor is on call', then each marks themselves off duty in separate transactions under snapshot isolation. Both commit; now nobody is on call. Which change reliably protects the invariant?
Choose one
// the roadmap
Four pathways. One production engineer.
Subscribe once. Every pathway unlocks as it ships. Each one is twelve labs built around real incidents — not language tutorials.
Go Backend Production Engineering
Twelve production incidents and the systems behind them — HTTP framing, N+1 queries, Redis OOM, retry storms, goroutine leaks, write-through caches. Real services, real failures, scored on more than 'did it pass.'
- 01Build
Build a real HTTP server
Sockets, request parsing, routing. No net/http allowed.
- 02Debug
REST API returns 500s under concurrency
Logs are panicking. Find the data race.
- 03Build
LRU cache, 5M ops/sec
O(1) get/put. Hit the perf target on a single core.
- 04Debug
Checkout p99: 80ms → 2.3s
Cache TTL expired and the dashboard lit up. Why?
- 05Build
Token-bucket rate limiter
Per-key buckets. Survive the included DDoS sim.
- 06Debug
Postgres CPU pegged at 100%
5M-row table. EXPLAIN ANALYZE is your friend.
- 07Build
Redis-backed job queue
At-least-once. Idempotency. Visibility timeouts.
- 08Debug
Redis memory exploding
OOM command not allowed. Find the unbounded growth.
- 09Build
Circuit breaker on a flaky downstream
Fraud-check melts checkout. Build the state machine that fails fast.
- 10Debug
Cascading retry storm
Service B is degrading. Service A is making it worse.
- 11Debug
Goroutine leak
Memory creeps. pprof shows 50k stuck goroutines.
- 12Build
Write-through cache
Stay consistent under Postgres and Redis failure.
- Every lab graded on correctness, latency, memory
// pricing
Less than one Saturday of LeetCode Premium burnout.
All tiers include every lab, every score dimension, and the full pathway graph. Founding members lock today's price forever.
Trial
Try two labs. No card needed.
- 1 Debug Lab
- 1 Build Lab
- Multi-dimensional scoring
- 5 Cracked Knowledge questions
Pro
For working engineers.
- All 12 labs
- Full pathway access
- Multi-dim scoring & benchmarks
- AI tutor on every lab
- Cracked Knowledge question bank
- Future pathway upgrades
Founding member
Locked at $29/mo forever during launch.
- Everything in Pro
- Locked price forever
- Direct line to the founder
- Early access to v1 features
- Cracked Knowledge question bank
Founding price is open for the launch window.
// from the founder
The thing nobody is teaching is the thing the job actually is.
Four years at a top Ivy League CS program. Three FAANG roles after that, with more big tech offers along the way than I knew what to do with. None of it prepared me for the actual job. Almost everything I'd been trained on turned out to be approximately useless next to what was expected of me on day one.
I've since had the same conversation a few hundred times with the engineers I respect most — staff and principal ICs at the companies you've heard of. The story never changes. What mattered on the job — reading traces, reasoning about latency, navigating a flamegraph, untangling a goroutine leak — got learned on call. By being there when it broke. By accident.
The gap between “graduated from a great CS program” and “can be trusted with the pager” is wider than the industry pretends. Algorithm puzzles don't close it. LeetCode doesn't close it. There is no platform on the internet that even tries to.
Cracked SWE is what I wish existed when I was in college, and what I would have paid serious money for in my first year out. The labs are tight. The artifacts are real. The dashboards aren't cartoons and the bugs aren't scripted. Every lab teaches a thing a senior engineer actually knows, in the shape they actually know it.
If that sounds like the way you want to spend your next ten hours, the founding tier is open for now. After 100 spots, the door closes and Pro pricing applies for everyone else.
// frequently asked
The questions worth answering.
Short answers to the questions a careful engineer asks before handing us a card.
Still curious? Email hello@crackedswe.io