Junior, middle, senior: the difference isn’t years — here’s the line I actually use

Marcus Dalton

Marcus Dalton

September 18, 2026

Junior, middle, senior: the difference isn’t years — here’s the line I actually use

I have sat in calibration meetings where we argued about a number. Five years. Eight years. “They’re a senior because they were a senior at the last company.” I have also sat with a person who had two years on the clock and already owned a payment path I would trust at 2 a.m. Years are a proxy. Proxies leak.

The line I actually use, as someone who has been the junior, the middle, the senior, and the manager writing the promo doc, is not a competency matrix with forty boxes. It is three questions about blast radius, about unfinished work, and about who has to be in the room. Titles are cheap. Those questions are not.

Junior: I still own the outcome. You own a slice I can see

A junior is not “someone who does not know React.” I have hired juniors who knew React better than I did. A junior is someone whose work I still have to finish in my head. I can give them a ticket that is bounded: add this field, follow this pattern, write the test that already has a sibling. I cannot yet give them “customers cannot update a payment method after a failed dunning cycle” and walk away for two days.

That is not an insult. It is a staffing fact. The job of a junior is to turn a clear slice into a correct change, and to ask when the slice is not clear. The juniors I fight to keep are the ones who ask early and specifically: “The ticket says update the card. Stripe’s customer portal already does this. Are we duplicating it or wrapping it?” The juniors who struggle are not the ones who Google. They are the ones who invent a second billing truth because they did not want to look blocked.

I expect a junior to:

  • Follow the local pattern even if they would have designed it differently. Argue in the PR, do not silently fork the architecture.
  • Run the tests that exist. Add a test when they change a branch. Not a philosophy of TDD. A habit of not making me the test suite.
  • Say what they do not know before the demo, not after the deploy.

I do not expect them to estimate a project, to negotiate a scope cut with product, or to notice that the ticket contradicts last quarter’s incident. Those are middle skills. Teaching them is my job. Pretending they already have them is how we set people up to fail a “senior” interview in eighteen months.

Middle: I can leave the room. I still want a review on the dangerous parts

Middle — mid-level, “engineer,” whatever your ladder says — is the title most people actually are and the one we never define. My definition: I can hand you a problem with an unclear edge, and you will return with a design I can argue with, not a shrug and a pull request that does three things.

A middle engineer owns a feature across the stack they were hired for. In my last backend-heavy team that meant: the Postgres migration, the Sidekiq job, the API shape, the metric, the runbook sentence. They still ping me when the change touches money, auth, or a delete that cannot be undone. That ping is not permission-seeking. It is respect for blast radius.

The middle engineers I promote are the ones who make the junior next to them faster without turning into a gate. They write the note in the repo that says “we preload lines here because the show page N+1’d in January.” They do not hoard context in Slack DMs. They also say no to a fifth scope on a Friday without needing me to say no first.

What I do not use as the line: number of languages, number of years, whether they have done Kubernetes. I have had middles who could not explain a kube manifest and still owned a billing domain I would bet the company on. I have had “seniors” who could recite twelve tools and could not ship a migration without a hero review.

Two engineers reviewing a design at a whiteboard in a small office

Senior: you own the problem including the parts that are not code

Senior, on my teams, is not “writes better abstractions.” Sometimes they write fewer. Senior is: you notice the ticket is the wrong ticket. You find the finance person who knows that “refunded” and “voided” are not the same event. You cut the project so that the first ship is a real user outcome, not a platform. You leave the system more operable than you found it — a dashboard, a log line, a delete path that does not require a one-off script.

I also expect a senior to be wrong in public and to change their mind when the trace says so. I have worked with seniors who treated architecture as identity. They are expensive. A senior who can say “I wanted four services; the monolith was right; here is the module boundary instead” has saved me more money than any clean-architecture diagram.

The other senior tell: they reduce the number of meetings I have to attend. Not because they hide work. Because they bring a recommendation, the trade-off, and the people who will be mad. I can say yes or no in ten minutes. A middle brings options. A senior brings a decision I can still overrule. If I have to invent the decision every time, they are a strong middle, and that is a good thing to be. It is not senior.

Staff and principal are a different conversation — scope across teams, a year-long bet, the political work of killing a platform. I am not stuffing that into this piece. Most companies use “senior” to mean “we need you to own a domain without a babysitter.” That is the line I am talking about.

What I ignore on purpose

Leetcode as a seniority signal. I have used interview puzzles. They tell me if you can manipulate a graph on a whiteboard. They do not tell me if you will ship a safe migration. I will not pretend a Hard problem makes you senior. I will also not pretend a person who cannot write a loop is ready for a production on-call. There is a floor. It is not the ceiling.

FAANG titles imported wholesale. A Senior SDE at a 20,000-person company and a senior at a 12-person shop are different jobs. The first might own a sliver with huge scale. The second might own billing, hiring, and the vendor relationship. I translate. I do not copy-paste levels. If I am hiring from a big company into a small one, I ask: when did you last change the product outcome, not the ticket state?

Years. I will look at years to sanity-check a resume. I will not use them as the rule. I have seen eight-year middles who were kept in a silo. I have seen three-year people who had to own a domain because the company was on fire and they did not waste the fire. Context is the real clock.

Confidence. Some of the best seniors I know are quiet in the first meeting. Some of the worst are fluent on day one. I watch the second month: who updates the doc, who greps the logs, who remembers the customer who will break.

How I talk about this in a 1:1 without turning it into a TED talk

When someone asks “what do I need for senior,” I do not hand them a book list. I pick one domain they already touch and I make the line concrete.

Example I have actually used: you are middle on the invoicing API. To be senior here, I need you to own the Stripe webhook path end to end — the idempotency table, the alert when we fall behind, the conversation with support about what we show the customer when tax fails. I need you to write the design before the code. I need you to tell product which three requests we will not do this quarter. I do not need you to rewrite it in a new language. I do not need you to mentor six people if we only have four. Mentorship is a senior behavior when we have juniors. It is not a substitute for owning a dangerous path.

If they want a checklist:

  1. Can you take an ambiguous outcome and return a sequenced plan with a first ship that is user-visible?
  2. Can you change production without me in the review, except for the truly irreversible bits you still flag?
  3. Can you make the next person faster — a doc, a test, a smaller interface — without becoming a bottleneck?
  4. Can you disagree with me using evidence from the system, not from a blog post?

If three of those are yes and one is growing, we start the promo packet. If they are all “I could if I had time,” the problem is usually the team’s load, not their talent. Then the conversation is about what I will take off their plate, not about a title.

Engineering manager and developer in a one-on-one at a small meeting table

The middle-to-senior gap that is not technical

The hardest promotion I have written was for someone whose code I already trusted. What they lacked was the habit of naming the trade-off to people who do not read PRs. They would ship a good design and then be surprised when sales promised the thing the design explicitly deferred. Senior includes the unglamorous loop: write the decision, drop it in Slack, confirm it in the weekly. That is communication, not “soft skills” as a smear. It is how the system stays true.

The other gap is taste about complexity. Middles often add a service, a queue, a feature flag platform, because they can. Seniors add those when the current shape is actually hurting. I have rejected promo packets that were a list of technologies introduced. I have approved packets that were a list of technologies removed. The line is not “more architecture.” The line is “the next incident will be cheaper.”

On-call is part of this. I will not promote someone to senior who has never been the person who got the page, or who has been shielded from it. I will also not use “survived a terrible rotation” as the only evidence. I want to see the follow-up: the alert that was too noisy got fixed, the runbook got a sentence, the bug that woke them did not wake the next person for the same reason.

What does not change when the title does

You still write code. I do not believe in seniors who only draw. A senior week that is all meetings is a smell — sometimes of the org, sometimes of the person hiding from the compiler. You still get reviewed. I still read the money path. You still look things up. I still look things up. Senior is not omniscience. It is a different default about who moves first.

You still have days where you are junior in a new domain. I was senior on billing and junior on a Kotlin service we inherited. I said so. The people who cannot say so become the people who design from memory and ship a mess. Titles do not travel across every repo. Honesty does.

Compensation and title are a market. I will fight for money when the work is senior and the title is stuck. I will not invent a title to retain someone whose work is still middle. That lie becomes the next calibration fight and the next junior who wonders what the word means. If the market says my senior band is low, that is a company problem to fix in the band, not by blurring the line.

The one-sentence versions I use when someone corners me in a hallway

Junior: you make a well-specified change correctly and you escalate the unspecified parts.

Middle: you specify a lot of the change yourself and you ship it across the seams of your stack. I am a consult, not a copilot.

Senior: you choose the change, including the option to do less, and you own the aftermath — users, ops, the next engineer. I hear about it in the weekly, not in the incident channel first.

Years can match those sentences. Often they do. When they do not, I believe the sentences. I have been wrong in both directions — I have held someone back because I liked doing the interesting work, and I have pushed a title too early because a headcount plan needed a senior box checked. The first error is more common than we admit. The second is how you get a title inflation that makes the next hire impossible to level.

I still write years on a req when legal or immigration asks. I still tell a candidate the band. Then I spend the interview on a real problem from our domain and I watch who asks the question that changes the ticket. That question is the line. Everything else is decoration we use because decoration is easier to put in a spreadsheet.

More articles for you