crackedswe.io
Try it free
v0 · founding members open

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.”

Try it freeSee the pathway
Debug LabsBuild LabsReal SandboxesGo · Java · C++ · Python
lab/checkout-p99 — debug · medium · ~60 minp99 2.34s
Lab 04debugmedium

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.
cmd+entersubmit
handler.go
1func CheckoutHandler(w http.ResponseWriter, r *http.Request) {
2 cart := loadCart(r.Context(), userID)
3
4 for _, item := range cart.Items {
5 // ⚠ one DB call per item — 47 round-trips
6 price, _ := db.Query(priceByID, item.ID)
7 item.Price = price
8 }
9
10 total := computeTotal(cart)
11 respond(w, total)
12}
Terminal
Tests
Artifacts
Explain
Pager timeline
  • 07:14 deploy went out
  • 07:21 cache TTL expired
  • 07:22 p99 1.8s
  • 07:25 dashboards red
pg_stat_statements
query          calls   mean_ms
─────────────  ──────  ──────
SELECT price …  47     38.2
INSERT cart …    1      4.1
p992.34s
target< 200ms
Sandbox boots in < 5s. Edits live-sync. Submit when you're sure.

// what you'll touch

The artifacts of real engineering.

Every lab gives you the same things a senior engineer uses on a tough day: stack traces, dashboards, logs, code. Not a textarea.

request
checkout.Handler
loadCart
for items
db.Query
rows.Scan
Profiling

Flamegraphs that point at the slow path.

handler.go
// hot path
func Checkout(w, r) {
  for _, item := range cart.Items {
    price, _ := db.Query(
      "SELECT ...", item.ID)
  }
}
Code

Live editor against a running service.

p99 latency
186ms
↓ 92%
15m agonow
Metrics

Real dashboards. Real regressions.

>INFO request /checkout user_id=4912
>DEBUG cart.load items=3 ms=4
>DEBUG db.query products id=… ms=18
>ERROR db.query timeout after 5000ms
>DEBUG retry attempt=1 backoff=200ms
>INFO checkout.complete ms=187
Logs

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

ConcurrencyObservabilityData modelingPerformanceFailure handling
Where you think you are
Where labs prove you are

Five engineering axes that decide whether you survive an incident. The labs close the gap one artifact at a time.

LeetCode et al.
Cracked SWE
What you do
Solve algorithm puzzles in a textarea
Debug & build real backend systems in a sandbox
What you see
A test passes or fails
Logs, traces, flamegraphs, dashboards, terminal
What's measured
Runtime in seconds
Correctness, p99 latency, memory, allocations
What you learn
Trick patterns you'll forget after the interview
Production debugging instincts you'll use Monday
Who it's for
Candidates preparing for one specific interview type
Engineers who want to do the job

// anatomy of a debug lab

You don't read about a bug. You hunt it.

Lab 04 · Debug · Medium · ~60 min
01

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

02

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.

checkout.Checkout
loadCart
validateInventory
finalize
03

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.

p99 latency−71%
beforeafter
04

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.

14 / 14 tests passed
BenchmarkProcessSuccess
baselinetargetworld-class
Your run
247 ns/op · 0 allocs

// 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

BuildEasyLab 01

Sockets, request parsing, routing. No net/http allowed.

socketstcphttp-internalsrouting
GET /checkout HTTP/1.1
Host: Cracked SWE
User-Agent: lab-runner
Connection: keep-alive

200 OK · 187ms · 1.2kb

// 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.'

  1. 01

    Build a real HTTP server

    Sockets, request parsing, routing. No net/http allowed.

    Build
  2. 02

    REST API returns 500s under concurrency

    Logs are panicking. Find the data race.

    Debug
  3. 03

    LRU cache, 5M ops/sec

    O(1) get/put. Hit the perf target on a single core.

    Build
  4. 04

    Checkout p99: 80ms → 2.3s

    Cache TTL expired and the dashboard lit up. Why?

    Debug
  5. 05

    Token-bucket rate limiter

    Per-key buckets. Survive the included DDoS sim.

    Build
  6. 06

    Postgres CPU pegged at 100%

    5M-row table. EXPLAIN ANALYZE is your friend.

    Debug
  7. 07

    Redis-backed job queue

    At-least-once. Idempotency. Visibility timeouts.

    Build
  8. 08

    Redis memory exploding

    OOM command not allowed. Find the unbounded growth.

    Debug
  9. 09

    Circuit breaker on a flaky downstream

    Fraud-check melts checkout. Build the state machine that fails fast.

    Build
  10. 10

    Cascading retry storm

    Service B is degrading. Service A is making it worse.

    Debug
  11. 11

    Goroutine leak

    Memory creeps. pprof shows 50k stuck goroutines.

    Debug
  12. 12

    Write-through cache

    Stay consistent under Postgres and Redis failure.

    Build
  13. 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

Free

Try two labs. No card needed.

  • 1 Debug Lab
  • 1 Build Lab
  • Multi-dimensional scoring
  • Knowledge graph preview

Pro

$29/mo

For working engineers.

  • All 12 labs
  • Full pathway access
  • Multi-dim scoring & benchmarks
  • Progression & XP
  • Future pathway upgrades
Limited

Founding member

$19/mo

Locked at $19/mo forever. First 100 only.

  • Everything in Pro
  • Locked price forever
  • Founding badge on profile
  • Early access to v1 features
  • Private Discord (coming soon)

100 of 100 founding spots remaining

// 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.

Founder, Cracked SWE
Database infra engineer · current FAANG
Claim a founding spot

// frequently asked

The questions worth answering.

Short answers to the questions a careful engineer asks before handing us a card.

LeetCode tests if you can pass interviews. Cracked SWE tests if you can do the job. We give you real running services, real logs, real traces. You debug and build production-grade backend systems, scored on correctness, latency, and memory — not just whether the test passed.

Still curious? Email hello@crackedswe.io