← Jeremiah Walters

Field notes

The Senior‑to‑Principal Gap: It's Not More Code

Notes from the middle of the climb.

I'm a senior engineer working toward principal-level scope. I'm not there yet, so read this as notes from the middle of the climb, not advice from the summit.

But I've been paying close attention to what changes at the next level, and the biggest lesson so far is uncomfortable.

The gap is mostly not about technical skill.

Cartoon: a determined robot climbs a ladder. The bottom rungs are labeled senior. The top rungs fade into a dashed cloud labeled principal scope. A bouncing pin beside it says you are here. Principal scope Senior You are here
Notes from the middle of the climb, not advice from the summit.

At senior level, you're judged largely on what you deliver. At principal level, or staff-plus depending on your company's ladder, you're judged on what happens because of you, often in places you never touched directly. Tanya Reilly's The Staff Engineer's Path organizes the whole job around three things: the big picture, execution and leveling up the people around you. [1] Not one of them is "write more code."

Here's what I've noticed.

1. Problems Over Tasks

Senior engineers are very good at taking a well-defined problem and solving it well. The next level is about finding the problem worth solving in the first place.

That means sitting with questions like: What keeps going wrong across teams, not just on mine? What are we spending effort on that we shouldn't be? What will hurt us in a year if nobody looks at it now?

In my area, reliability, this shows up as a shift from fixing incidents to asking why a class of incident keeps happening, and whether it can be detected or prevented across many systems at once. One I keep running into: the same retry mistake, clients hammering a struggling dependency on a fixed delay, showing up in service after service. Fixing each incident is task work. A scanner rule that catches the pattern everywhere, plus a demo that shows why it matters, is problem work.

Task work: fix the incident

svc 1!fix #1svc 2!fix #2svc 3!fix #3svc 4!fix #4svc 5!fix #5same incident, five times

Problem work: fix the pattern

svc 1svc 2svc 3svc 4svc 5one rule that catches the patternfixed once, caught everywhere
The fix is task work. The pattern is problem work.

2. Multiplying Others Instead of Outworking Them

There's a ceiling on what one person can ship. At senior level, the way to do more is often to work harder or faster. That stops working at the next level, because the scope is too big for one person.

What replaces it is multiplication: making other engineers more effective. In practice:

Illustrative chart of impact over time. Outworking everyone rises quickly, then flattens at a dashed line labeled one person's ceiling. Multiplying others starts slower, then keeps climbing past the ceiling. impact time one person's ceiling Outwork everyone Multiply others
Illustrative, not measured. Working harder has a ceiling. Making others more effective doesn't.

Self-check: If I disappeared for a month, what would keep working because of something I built or wrote?

3. Impact Has a Blast Radius

In reliability work, blast radius is how far a failure spreads before something stops it. Microsoft's Azure Well-Architected guidance tells you to analyze the blast radius of every failure case and design to minimize it. [2] I've started thinking about my own impact the same way.

At senior level, the radius is mostly your team. A good decision helps your service. A bad one hurts it. At the next level, the radius grows. A design doc becomes the template for ten teams. A default you set ships everywhere. A pattern you teach shows up in code you'll never review.

Concentric rings around you: your team, neighboring teams, the org, and everyone who copies your work. The left half, in purple, is the impact radius: good ideas travel this far. The right half, in orange, is the blast radius: mistakes travel just as far. YouYour teamNeighboring teamsThe orgEveryone who copies it Impact radius a design doc becomes ten teams' template Blast radius a wrong default ships just as far
Same rings, both directions. The reach that multiplies a good decision multiplies a bad one.

That cuts both ways. The same reach that multiplies a good idea multiplies a bad one. A wrong standard, an unexamined default or an overconfident recommendation travels just as far, and it's much harder to recall than a bad deploy.

So I'm learning to treat my own decisions like a production change:

Lesson: Bigger scope means bigger reach, in both directions. Stage your influence like a deploy.

4. Influence Without a Reporting Line

Principal engineers usually don't manage the people whose work they shape. Their influence comes from credibility, clarity and relationships.

I'm learning that influence is mostly built before you need it. It comes from being right often enough, being honest when you're wrong, writing things down clearly and showing up for other teams' problems. When it's time to push for a technical direction, all of that is already in the bank.

I'm also learning that a small working demo often persuades better than a long argument. A slide asks people to believe you. Something that runs lets them see for themselves.

5. Strategy You Can Explain in a Paragraph

Technical strategy sounds grand. In practice, the best versions I've seen are short. Richard Rumelt boiled good strategy down to a kernel: a diagnosis, a guiding policy and a set of coherent actions. [3] Mine looks like this:

Where we are
The honest diagnosis, in two sentences.
Where we need to be
The outcome, specific enough to know when we're there.
The two or three bets
The few moves that get us there, and why these.
What we're not doing
The tempting work we're choosing to skip, named out loud.

The test: if someone read only this, would they make the right call without me?

A strategy that fits on one page, because the hard part is choosing.

The hard part isn't writing it. It's choosing. A strategy that tries to do everything ends up saying nothing. I'm practicing one-page strategies for my own area and running them through that test.

6. Protecting Time From Execution Toil

This one surprised me. As your scope grows, so does the volume of small operational work: status updates, meeting prep, tracking, chasing. It's all legitimate, and it can quietly eat the time you need for higher-leverage work.

Google's SRE book has a name for this: toil. Work that's manual, repetitive, automatable and leaves nothing lasting behind, and that grows as the system grows. Their teams aim to keep it under half of anyone's time. [4]

I've started treating my own toil as an engineering problem. Which recurring tasks could be templated, automated or delegated? Which meetings exist only because information isn't written down anywhere? Lately I've been using AI tools for some of the summarizing and drafting, with a strict rule that I check anything before it leaves my hands.

The goal isn't to do less. It's to keep enough time for thinking.

7. Being Comfortable With Less Visible Credit

At senior level, your name is on the things you built. At the next level, more of your impact shows up in other people's work: the team that avoided a mistake because of your review, the engineer who grew because you gave them a stretch project.

That's hard if you're used to being measured by output. It's also why careful record-keeping matters. If your impact is indirect, you need to capture it deliberately and honestly, including what others did.

What I'm Doing About It

My current plan, in case it helps anyone on a similar path:

The Honest Part

None of this is a formula. Companies define the level differently, and plenty of people do principal-level work without the title.

But the common thread I keep seeing is this: the next level isn't about being a better individual engineer. It's about making the whole system around you better, and being able to explain how.

I'll report back on what I get wrong.

References

  1. Tanya Reilly, The Staff Engineer's Path (O'Reilly, 2022).
  2. Microsoft Learn, Azure Well-Architected Framework, Reliability design principles.
  3. Richard Rumelt, Good Strategy Bad Strategy (2011). Summary: The kernel of good strategy.
  4. Google, Site Reliability Engineering, Chapter 5: Eliminating Toil.