How Do You Know You're Actually Senior?

Published: October 15, 2026
Tags: Career, Seniority, Software Engineering, Certification, C++

---

The Only Job Title You Award Yourself

Think about how you got every other credential in your career. Your degree had an assessment. Your driving licence had a test. Even your gym membership has an induction. But "senior developer"? At some point you simply started writing it on your CV — or someone above you typed it into a job requisition — and that was that. Nobody examined you. Nobody verified it.

Sandro Mancuso opens The Software Craftsman with a passage that should be taped to every developer's monitor: developers are typically considered senior "according to the number of years they have worked in the industry and not according to their knowledge." His follow-up is the famous one — there is a huge difference between having ten years of experience and having one year of experience repeated ten times.

Two engineers sit side by side. Both started in 2016. One spent a decade cycling through domains, paradigms, codebases, and failures — each year adding a layer. The other shipped the same kind of feature, in the same stack, in the same way, for ten consecutive years. Their CVs are identical. Their capability is not. And the uncomfortable part? From the inside, they feel identical too.

---

What "Senior" Is Actually Supposed to Mean

If seniority isn't tenure, what is it? Gergely Orosz, writing in The Pragmatic Engineer, lays out the frameworks Big Tech actually uses to level engineers — and none of them mention years served. The rubric is about scope and influence: the higher your level, the wider the surface area you're expected to own, and the larger the group of people you must influence to deliver it. A mid-level engineer delivers a feature. A senior engineer shapes how a team delivers a whole problem area — handling ambiguity, raising the bar through reviews and mentoring, and communicating clearly enough that others can build on their thinking.

Amazon's SDE3 expectations — the industry's informal definition of "senior" — include a line worth sitting with: "Your team is stronger because of your presence; but it does not depend on your presence to be successful." A genuine senior isn't a key dependency. They've made themselves replaceable by making everyone around them better.

So real seniority is a bundle of measurable expectations: deeper technical judgment, wider scope, autonomy in the face of ambiguous problems, and influence that multiplies the people around you. When that bundle is real, it unlocks things — top-of-band salaries, staff-plus tracks, the quiet confidence of walking into interviews knowing you belong in the room. When it's a title unbacked by substance, it eventually collides with reality — usually in public, usually at the worst moment.

Which raises the question nobody wants to ask: how would you know which one you are?

---

The Plateau Is the Default

Here's the uncomfortable science. K. Anders Ericsson — the researcher behind the deliberate-practice body of work — found in a peer-reviewed overview of professional expertise that the traditional markers we lean on, length of experience, reputation, and perceived mastery, show only a weak relationship to actual observed performance. In most professions, people improve rapidly early on, then settle into what Ericsson calls a "stable, average level of performance" — and stay there. The graph goes flat while the calendar keeps filling in years.

That flat line is the plateau, and it is the default outcome. Not the exception — the default. Experience is necessary, but it isn't sufficient. Later reviews of the deliberate-practice literature (Macnamara and colleagues) sharpened the picture further: hours logged explain only part of what separates top performers. What matters is the quality of practice — structured, at the edge of your ability, and crucially, driven by feedback.

And that last part is where working developers are quietly stranded. Deliberate improvement requires a feedback loop — some external instrument that tells you where your understanding actually ends. Most senior-tenure engineers don't have one. Performance reviews measure your output in your specific context, not your depth against the field. Side projects exercise what you already enjoy. Colleagues defer to the title on your email signature. Nothing in an ordinary working week pushes back and says: this part of your knowledge is thinner than you think.

You cannot calibrate yourself from the inside. Confidence is not evidence — it's just the feeling of not having been tested recently.

---

What a Real Benchmark Looks Like

A benchmark worth trusting has three properties. It covers the whole domain, not just the slice your job happens to exercise. It scales in difficulty, so "I passed the easy part" can't masquerade as mastery. And it scores you against a fixed standard — not against whether your current teammates know less than you do.

That's the structure behind ProvedExpert's C++ certification track. Rather than a single pass/fail hurdle, it's built as a ladder of distinct depth tiers — each one measuring a different claim about what you know:

• C++ Foundation — core language fluency: the fundamentals every working C++ developer should have cold.
• C++ Professional — working-depth command of the modern language and its idioms.
• C++26 Expert — the top of the ladder: language internals, modern standard features through C++26, performance semantics, and the kind of edge-case understanding that separates "uses C++ daily" from "actually senior in C++."

The point isn't that an exam certificate is seniority — nobody is claiming a score replaces the scope-and-influence rubric above. The point is that the technical half of seniority is the half you can actually measure, and most people have never measured it once. A structured benchmark turns "I've been writing C++ for ten years" into a verifiable statement: here is where my depth actually sits on a fixed scale.

And the ladder framing matters more than it first appears. If you're genuinely senior, you shouldn't fear the top tier — you should be curious about it. The feeling you get reading "Expert-level C++26" right now — is it quiet confidence, or a small itch of doubt? That itch is information.

---

Depth Is Only Half the Rubric

Remember what the seniority frameworks actually measured: scope, autonomy, communication, and influence — the ability to move a group of people toward an outcome without formal authority over them. Technical depth is the half of seniority you can prove with a benchmark. Influence is the half you build.

If the honest self-audit in this post surfaced a gap on that second half — if you routinely get the right answer but struggle to get it adopted — that's a different skill with a different training path. CourseThread's Emotional Intelligence at Work email course is built for exactly that axis: reading rooms, handling pushback, and exercising influence as an individual contributor. It pairs naturally with the technical side — one course for the influence half of the rubric, one benchmark for the depth half.

---

Find Out Which Tier You'd Actually Land In

Strip away the title for a moment. Forget what your CV says and what your teammates assume. The question underneath all of it is simple: if you sat down today, in front of an Expert-level assessment of the language you've staked your career on — where would you land?

Most senior-titled developers have never answered that question honestly, because they've never had an instrument that could answer it. Now you do. The worst case is you discover a gap privately and spend a few evenings fixing it — an absurdly good trade. The best case is you finally know, with evidence, that the title fits.

Take the C++26 Expert assessment and find out if you're actually senior →