Senior Is What You Do When Nobody Knows the Answer
One honest test: what someone does when nobody knows the answer. Vague requirements, a misbehaving system, nothing to look up, and someone has to keep moving. The rest is decoration.
Senior has one honest test. Watch what someone does the next time nobody knows the answer. Everything else is decoration.
Open any "Senior Software Engineer" posting. You'll find a wishlist of eighteen cutting-edge technologies, mastery required. Not one item on that list predicts the test. That works fine right up until you have to decide who deserves the title, or whether to trust the person who already holds it.
The fog test
On a good day, the junior and the senior produce nearly identical code. The tell is the bad day. The requirements are vague. The system misbehaves in a way nobody has seen. There is no answer to look up. That's where the title is earned or exposed.
A senior keeps moving through that fog. Makes a defensible call without all the information. Absorbs the ambiguity so the people around them can keep working instead of freezing.
Bezos put a number on the fog in his 2016 shareholder letter: "Most decisions should probably be made with somewhere around 70% of the information you wish you had. If you wait for 90%, in most cases, you're probably being slow." 70%, not 90%. Deciding at 70 and owning the miss is the job. Waiting for certainty is still freezing.
Absorbing ambiguity for the team has an edge: it disqualifies the office hero. But first, it clears away the other decorations.
What senior is not
Start with the eliminations. Not the highest salary in the room, obviously. The other three need dismantling.
Not years on the clock. I've worked with people who'd been writing code for two and a half decades and still carried the toolkit of someone fresh out of their first tutorial. They hadn't done twenty-five years. They'd done year one, twenty-five times. I've also worked with developers barely out of university who saw three moves ahead. Time served buys you stories. Not seniority.
This isn't just my anecdote. DeMarco and Lister measured it in the Coding War Games: over 600 developers from 92 companies, working the same benchmark exercise. The same industry that writes "8+ years required" has had the result since the eighties. The finding, printed flat in Peopleware: "People who had ten years of experience did not outperform those with two years of experience." Ten years versus two, no difference. The only measured experience effect: people with under six months in the exercise's language did worse.
Not a tour of technologies at Hello World depth. If you never read past the opening example, never hit the problem where even the internet has only unanswered questions, you don't know the thing. You met it. A CV with twenty logos usually means twenty introductions, not twenty masteries.
Not the patch collector. The engineer who accumulates workarounds and quietly fears the refactor, because the patches are job security and the refactor is risk. That's tenure defending itself.
The one-word version
Problem-solver.
A senior owns a feature end to end, and "end to end" is the load-bearing part. Not just writing it. Planning it. Testing it. Keeping it alive in production long after the demo. Arguing with the stakeholder about whether it should exist at all, before a line gets written. A senior understands the business well enough to push back on it. Juniors rarely can. Seniors are negligent not to.
They carry design risk like it weighs something, because it does. There is always a gap between the whiteboard and the live system the design has to survive inside, a system full of moving parts that never read your diagram. A senior feels that gap before shipping into it.
Liability with Tenure
The indispensable hero is not senior. The engineer who fixes everything because only they can. Who looks heroic precisely because the bus factor is one. I have a name for that pattern: Liability with Tenure. Good intentions, real skill, and a single point of failure with a badge.
This isn't a rare pathology. In 2016, Avelino, Passos, Hora and Valente measured the truck factor of 133 popular GitHub projects. 65% sat at a truck factor of 1 or 2: one or two departures away from stalling. Bus-factor-one is the measured default.
So here's the tell. The fake senior hoards the knowledge that makes them necessary. The real one gives it away as fast as they can and goes looking for the next hard thing.
One-way doors
There's a quieter version of the same judgment in how seniors decide. Some calls are cheap to reverse: decide fast, fix later if wrong. Some are not. The schema you'll be stuck with for five years. The data migration with no undo. Those decisions set the ceiling on everything built after them.
Bezos gave this instinct its name too, in his 2015 shareholder letter. Type 1 decisions are one-way doors. Walk through and you don't get back, so you go slow, deliberate, consult. Most decisions are Type 2, two-way doors, and should be made fast by people with judgment. The doors are his. Knowing which one you're standing in front of is what experience actually buys.
A senior slows down for the one-way doors. Forces the conversation. And when they walk through anyway, they own it personally. That sorting instinct, recoverable versus load-bearing, is compressed experience.
The part no grid can score
Underneath all of it sits the thing no competency matrix measures. Someone at peace with not having superpowers. Who says "I don't know" at zero cost to their ego, and measures people by what they can build, not their age, their accent, or who they pray to.
Seniority is what judgment does under uncertainty: make a defensible call, slow down for the one-way doors, own the miss, and give the knowledge away.
The word will keep meaning whatever the person using it wants it to mean. No committee is coming to fix that. Watch the bad day.