Make EF Core queries faster
Move a filter into SQL so your app stops loading the whole table.
Try the EF Core exercise → Data access path · ProThe proving ground for .NET developers
Become a measurably better engineer
Sharpen individual skills with focused puzzles, then preview the Production Outbox beta: a guided investigation of the failure modes and engineering decisions behind a reliable polling worker.
Solve Two Sum in the real editor. Create an account only after you pass.
Choose your first exercise
All three are free. No account or setup needed.
Refactor C# safely
Flatten nested null checks while keeping the existing behavior intact.
Try the refactoring exercise → Refactoring path · ProBuild faster C# solutions
Replace a slow pair-by-pair search with a hash map, then check the result.
Try the algorithm exercise → Algorithm patterns path · Pro
Solution.cs
Trapping Rain Water · Hard
1 public int Trap(int[] height)
2 {
3 int l = 0, r = height.Length - 1, lMax = 0, rMax = 0, water = 0;
4 while (l < r)
5 {
6 if (height[l] < height[r])
7 water += (lMax = Math.Max(lMax, height[l])) - height[l++];
8 else
9 water += (rMax = Math.Max(rMax, height[r])) - height[r--];
10 }
11 return water;
12 }
Submission graded 3 / 3 tests passed
✓ Example 1
Passed 0.18 ms
✓ Example 2
Passed 0.21 ms
✓ Large input (n = 1,000,000), must be O(n) hidden
Passed 6.84 ms
time budget 3% of 250 ms
memory 0 B allocated
Code submissions are measured like this, per test, server-side, unspoofable.
- graded puzzles, Easy to Hard
- 395
- graded puzzles, Easy to Hard
- code disciplines plus the System Design beta
- 7 + 1
- code disciplines plus the System Design beta
- mocks: real database, real compiler, real GC
- 0
- mocks: real database, real compiler, real GC
Two ways to practice
Puzzles for focused reps. Labs for guided system practice.
Train one engineering skill at a time, or follow a structured course through executable projects. Both make you write the code and prove the result.
Puzzles
C# coding challenges for focused practice
Solve a bounded problem, submit against hidden tests, and get production-grade feedback on correctness, performance, allocations, database plans, structure, or security.
Explore C# coding challenges →Katabench Labs
Build a production outbox
Preview the 8-lesson Production Outbox beta. See the incidents and decisions behind a reliable polling worker while its live workspace completes private-beta validation.
Preview Production Outbox →The disciplines
Seven disciplines, one bar: production quality
Algorithm drills are the smallest part of the job. Each code discipline trains a different fundamental of the craft. System Design adds a visual eighth practice surface.
125 puzzles
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.
130 puzzles
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.
54 puzzles
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.
22 puzzles
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.
20 puzzles
Secure Coding
Fix vulnerable-but-working code against real attack payloads: path traversal, SQL injection, SSRF, open redirect. Block the exploit without breaking the feature.
17 puzzles
Design Principles
Small katas on the principles behind the patterns: make a value object truly immutable, seal an aggregate's invariants, invert a dependency. Graded on structure, not just behavior.
27 puzzles
Test Writing
You write the tests. Your suite runs against a correct implementation and a set of planted-bug mutants, and passes only when it catches enough of them. Coverage that has to actually detect bugs.
395
graded puzzles and counting
Every one with a gate that green checkmarks can't fake, and new puzzles ship with every release.
Each card opens the focused practice catalog for that discipline. Prefer an ordered curriculum? Follow the C# and .NET learning paths.
Beta
System Design Studio
Do not just draw the architecture.
Make the design earn a pass.
Build a provider-neutral topology on a rich canvas. Deterministic rules check its paths, service boundaries, redundancy, messaging, storage, security, and observability, then a real lesson explains the tradeoffs after you solve it.
- 59
- progressive challenges
- 28
- standard components
- Easy to Hard
- foundations to capstone
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. Start with the ordered LINQ exercises, or explore the full set of EF Core exercises built around that feedback loop.
🧭 Your query plan, captured from the database, graded
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
1
Pick a puzzle
Seven code tracks plus the System Design beta, 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.
2
Run or Check
Run visible cases in the code editor, or build a topology and Check its paths, boundaries, redundancy, and dangerous bypasses. Iterate before the final grade.
3
Submit for grading
Your solution faces the discipline-specific grader: hidden tests and metrics for code, or deterministic semantic rules for a system topology.
Code runs in a hardened disposable sandbox. System Design topologies are validated and graded as bounded data, without executing learner code. See exactly what happens →
Guided Learning Paths
Stop wondering what to practice next
Follow a deliberate sequence across algorithms, data access, refactoring, architecture, and secure coding. The path supplies the curriculum. Katabench still makes you prove every step against real correctness, performance, query-plan, and structure gates.
Database and EF Core
High-Performance Data Access
✓Shape the query on the server
3Write the SQL directlyContinue →
Finish reward Badge · 250 XP · 25 gems
The grader
Built for deliberate practice
One platform, discipline-specific evidence. Every verdict is evaluated where it cannot 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, SQL-injection payloads, forged log lines, SSRF probes at the cloud metadata endpoint. 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.
Not another passive course
Learning Paths give you the route. The proving ground makes you apply it, defend it, and earn the progress that shows it stuck.
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, so what you practice here transfers to the job. Progress reflects proof, not time spent watching.
Learn concepts anywhere. Prove the skill 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. Go Pro when you want the whole craft under the grader, not just the algorithm track.
Free
$0/mo
Everything you need to get hooked. No credit card.
Pro
$19/mo
The full proving ground: every premium track, every gate, no daily cap.
Step onto the mat 🥋
Pick a puzzle, press Run, and see how fast your code really is. Then make it faster.
Try the grader, no signup