How senior .NET engineers actually keep their edge

Ask a junior how they're leveling up and you'll often hear "I'm doing LeetCode." Ask a strong senior the same question and the answer is stranger and more specific. They're not grinding problems for the green checkmark. They stopped caring about the green checkmark years ago, because the green checkmark was never the thing standing between them and a promotion.

Here's the gap nobody says out loud: correctness is table stakes. Once you can reliably make the tests pass, getting better at making tests pass has almost no marginal value. The senior's job, and the senior's reviews, and the senior's 2 a.m. pages, are about everything correctness doesn't catch.

Correctness-only practice trains the wrong muscle

Most coding practice measures one thing: did the output match? That's a perfectly good signal for your first year. It teaches you syntax, control flow, the standard library, basic data structures. But it has a ceiling, and the ceiling is low, because production doesn't grade on "did it return the right answer." Production grades on whether the right answer arrived fast enough, without melting the database, in code the next person can change, without a security hole.

Look at what actually ends up in a senior's review comments:

• "This works, but it's O(n²) and the input is unbounded."
• "You're loading the whole table into memory to count it."
• "This method is doing four things; split it."
• "This is one Where clause away from leaking other tenants' data."

Not one of those is a correctness bug. Every one of them is the kind of thing that gets you to senior, and the kind of thing correctness-only practice will never surface, because the tests were green the whole time.

What your suite says

returns_expected_result

✓

handles_empty_input

✓

handles_duplicates

✓

sample_cases_3_of_3

✓

✓ All green 4 / 4

What production measures

wall-clock 840 ms / budget 200 ms

✗

allocations 1.2 GB

✗

40 queries where 1 belongs

✗

query plan: seq scan

✗

✗ Over budget same code

Practice what production measures

The shift from junior to senior is mostly a shift in what your feedback loop measures. If you want to train like a senior, you have to practice against the same axes production grades you on. There are roughly five of them, and they happen to map cleanly onto the disciplines worth drilling.

Performance, with a budget

The first one is speed and allocation, measured, not eyeballed. A senior doesn't squint at a loop and guess it's fine. The way to internalize this is to feel a naive solution fail a wall-clock budget on a large input, not pass a tiny sample case. Take the difference between scanning a list and hashing it:

// Times out on 200k elements: O(n) lookup inside an O(n) loop.
var dupes = items.Where(x => items.Count(y => y == x) > 1).Distinct().ToList();

// Single pass, O(n): the senior's reflex.
var dupes = items.GroupBy(x => x).Where(g => g.Count() > 1).Select(g => g.Key).ToList();

Both are correct. Only one survives a few hundred thousand elements with a time budget attached. That's the entire point of grading on performance: the felt timeout teaches what a paragraph about Big-O can't.

Data-access shape

The second axis is the one that takes down more production systems than any algorithm: the queries your data layer actually emits. You can write LINQ that looks immaculate and generates forty round trips. The classic:

// Looks fine. Generates 1 query for orders, then 1 per order for the customer. N+1.
var orders = await db.Orders.ToListAsync();
foreach (var order in orders)
{
    Console.WriteLine($"{order.Id}: {order.Customer.Name}");
}

// One query, joined. The shape a senior reaches for.
var orders = await db.Orders
    .Select(o => new { o.Id, CustomerName = o.Customer.Name })
    .ToListAsync();

The correctness is identical. The first one is 40 queries where 1 belongs, and you only see that if your practice shows you the SQL. Reading the generated query, and noticing the difference between a seek and a sequential scan, is a senior reflex you can drill directly.

Design that survives change

The third is structure. Code is read and modified far more than it's written, so seniors practice keeping cyclomatic complexity, nesting, and method length down, and duplication out. This is hard to self-grade, because your own deeply nested method always feels reasonable to you. The signal has to come from a tool measuring it against a threshold, the same way a linter or an architecture fitness function would in a real codebase.

Architecture you can't quietly violate

The fourth is the shape of the system itself: dependency direction, layering, depending on abstractions rather than concretions. Juniors learn these as slogans. Seniors learn them as constraints that fail a build when you point your domain layer at your infrastructure layer. The only way to make "depend on abstractions" an instinct is to have a check fail when you don't.

Security, against an adversary

The fifth is the one correctness practice is structurally blind to, because the functional tests pass on vulnerable code. A starter that's correct but injectable, or that leaks data across tenants, sails through every "does it work" test. You only learn to spot it by facing an adversarial suite that actively tries to exploit your code, and having to shut the hole without breaking the feature.

Why this is hard to do alone

The catch is that all five of these need measurement you usually can't give yourself. You can grind correctness on your own all day. But you can't reliably feel a 200,000-element timeout, see your own generated SQL, get your cyclomatic complexity scored, or run an exploit suite against your own solution, not from a text editor and a Console.WriteLine.

That's the gap Katabench is built to close. Its seven tracks are exactly these disciplines, graded the way production grades them: the algorithms, database, refactoring, architecture, secure-coding, design-principles, and test-writing tracks each measure the thing that actually separates a senior from someone who can make the tests pass. Code is compiled and run server-side in an isolated sandbox, so the numbers are clean and comparable, not vibes.

Senior isn't a level you reach by doing more of the junior thing. It's a different set of muscles, and the only way to build them is to practice against the same scoreboard production uses. If you want to train on all five at once, that's what Pro unlocks. The green checkmark was never the finish line. It was the warm-up.