The proving ground for .NET developers
Write better, faster C#
Five disciplines — algorithms, SQL & EF Core, refactoring, architecture, secure coding — graded the way production judges you. Real query plans pulled from the database, real allocations measured by the GC, real design rules, real attack payloads. Not just green checkmarks.
Every submission is measured like this — per test, server-side, unspoofable.
- graded puzzles, Easy to Hard
- 241
- graded puzzles, Easy to Hard
- disciplines, each with its own grading engine
- 5
- disciplines, each with its own grading engine
- mocks — real database, real compiler, real GC
- 0
- mocks — real database, real compiler, real GC
Five disciplines, one bar: production quality
Far more than algorithm drills — the whole craft that separates senior .NET engineers, each discipline with a grading engine built for it.
Algorithms
Classic problems where correct is only halfway: hidden 200,000-element gates time out the O(n²) pass, and allocation budgets — measured by the GC, not estimated — fail the copy-happy one.
Database & EF Core
LINQ against a real PostgreSQL database. The grader captures the execution plan the engine actually chose — and grades it. Kill the N+1, earn the index scan.
Refactoring
Inherit working-but-awful code — including the famous Gilded Rose — and clean it up. Roslyn measures complexity, nesting, duplication, and method length while every test stays green.
Architecture
Multi-file katas graded on design itself: dependency direction, layer isolation, extracted interfaces, sealed types. A wrong dependency fails the same way a failing test does.
Secure Coding
Fix vulnerable-but-working code against real attack payloads — path traversal, ReDoS, log forging, Zip Slip. Block the exploit without breaking the feature.
241
graded puzzles and counting
Every one with a gate that green checkmarks can't fake — and new puzzles ship with every release.
Exhibit A
Your query plan is part of the grade
Submit LINQ and we run it on a real PostgreSQL instance seeded with tens of thousands of rows, capture the execution plan the engine actually chose, and grade the plan itself. Getting the right rows the wrong way is a visible, gradeable mistake here.
The obvious filter
.Where(o => o.PlacedAt.Year == 2024 && o.PlacedAt.Month == 3)
Sort (by id)
└ Seq Scan on orders
~60,000 rows · ⚠ full table read
- ✗ No full-table scan on orders
- ✗ Uses the placed_at index
- ✓ One round-trip
✗ 1 / 3 plan rules hold
The sargable rewrite
.Where(o => o.PlacedAt >= start && o.PlacedAt < end)
Sort (by id)
└ Index Scan using ix_orders_placed_at
~1,017 rows · ✓
- ✓ No full-table scan on orders
- ✓ Uses the placed_at index
- ✓ One round-trip
✓ 3 / 3 plan rules hold
Same rows returned. Same green tests. Only one earns the index scan — and the grade.
Straight from the engine
The plan comes from the database that just ran your query on realistic data — not a simulation, not a guess.
Readable verdicts
Full-table reads called out in red, index usage in green, row estimates on every node — even on hidden tests.
Rules, not vibes
No full-table scan, must use the index, one round-trip: pass/fail rules evaluated against the captured plan.
How it works
Pick a puzzle
Five tracks, Easy to Hard. Each puzzle states the goal, the constraints, and the bar you have to clear — a time budget, an allocation ceiling, a plan rule, a design rule.
Run the samples
Write C# in a full Monaco editor with syntax-aware highlighting and completions. Run visible sample cases — or your own custom input — and iterate fast.
Submit for grading
Your solution faces the full hidden suite. Per-test wall-clock time, a time-budget bar, allocated bytes, captured SQL with its query plan, and a character-level diff on every failure.
Your code runs server-side in a hardened, network-isolated sandbox — resource-capped, unprivileged, and destroyed after every run. See exactly what happens →
Built for deliberate practice
One grader, five kinds of judgment — every dimension measured where it can't be faked.
Allocations, measured by the GC
Every test reports server-measured elapsed time against its budget plus managed-heap allocations — median of repeated runs, so a GC pause can't flip your verdict. Some puzzles set hard budgets: a 100 KB input under a 16 KB allocation ceiling forces the in-place solution.
Real database, real plans
Database puzzles run on a real PostgreSQL instance seeded for your submission. Expand any test to see every SQL statement your LINQ produced, what it cost, and the plan the engine chose.
Structure, measured by Roslyn
Refactoring katas parse your source and measure it: cyclomatic complexity, nesting depth, method length, duplicate blocks. The tests stay green — the mess has to go.
Architecture rules as tests
Dependency direction, layering, abstractions, and sealed types are verified on every submission — a wrong dependency fails the grade, not a code review three weeks later.
Graded against real attacks
Secure-coding puzzles run a second, adversarial suite: traversal strings, catastrophic-backtracking inputs, forged log lines, decompression bombs. Exploits blocked and behavior preserved — both, or no pass.
Stuck? Reveal the solution
Give up gracefully: load a correct, optimal reference solution into the editor, study it, then reset and try to beat it from memory.
The gym, not the course
Courses and tutorials are where you learn. This is where you find out — and where it sticks.
You watch
Video courses
Great for absorbing new concepts — but nothing measures whether you can actually apply them under constraints.
You pass
Interview grinders
Binary right/wrong on correctness, optimized for getting hired. An O(n²) pass teaches the wrong lesson.
You get sharper
The proving ground
Graded on the qualities production actually judges: speed, memory, query plans, structure, security, design. Optimized for being better at the job.
Learn anywhere. Get sharp here. Built by a working .NET engineer and educator — for the engineers who want their practice to count.
Simple pricing
Start free, no credit card. Upgrade when you want all five tracks and every gate.
Free
$0/mo
Everything you need to get hooked. No credit card.
Pro
$9/mo
or $54/yr — Founder pricing — 6 months free
The full proving ground: every track, every gate, no daily cap.
Step onto the mat 🥋
Pick a puzzle, press Run, and see how fast your C# really is.
Start solving — it's free