Product Engineer

The ladder is one trunk that forks, then rejoins at the top. Up to Senior, everyone climbs the same rungs: intern, junior, mid, senior. Each is defined by what you can handle independently, not by years of experience or the tools you know. At Lead the path forks: scale through engineering depth (the IC track: Staff, Principal, Architect, the best engineer) or through people (the management track: Manager, Director, VP, the best manager). The two meet again at the top in the CTO: the one best at building product.

The progression is about one thing: how much raw material you can work with before you need structure or direction, and how much leverage your output carries. Through the trunk, the type of work stays the same and only the ambiguity you absorb grows. At Lead and above, the work itself changes: you stop doing it and start platformizing it, building the systems, or the people, that make it happen without you.

At a Glance

The ladder is one trunk that forks, then rejoins. Up to Senior everyone climbs the same rungs; at Lead the path forks, scaling either through engineering depth (IC) or through people (management). The two tracks rejoin at the top: the CTO is the one best at building product. The unit of leverage grows at every step.

        Intern → Junior → Mid → Senior → Lead
                                           │
             ┌─────────────────────────────┴───────────────┐
       IC:   Staff → Principal → Architect   ·  best engineer
       Mgmt: Manager → Director → VP          ·  best manager
             └─────────────────────┬───────────────────────┘
                                  CTO   ·  best at building product

Level	Track	Unit of leverage	What “good” looks like
Intern	trunk	A task	Given a clear problem, solution, and guidelines, executes the task and ships it.
Junior	trunk	A task, end to end	Owns a scoped task without step-by-step direction.
Mid	trunk	A problem	Turns a symptom into a problem and a Build-ready definition.
Senior	trunk	A direction	Finds the right problem from vague direction; shapes the process, not just their own output.
Lead	fork point	A team’s output	Multiplies a team: platformizes how the work gets done, accountable for its throughput and quality, not their own tickets.
Staff	IC	A system across teams	Turns a recurring class of problem into a platform others build on; sets technical standards beyond one team.
Principal	IC	A technical domain	Owns the hardest technical bets in a domain and sets direction within it.
Architect	IC · top	The whole system	Best engineer: owns the architecture end to end and the technical bets that shape the entire product; the standard everyone builds to.
Manager	Mgmt	A team of people	Owns delivery and the growth of each report; turns direction into goals and clears blockers.
Director	Mgmt	Multiple teams	Owns outcomes across teams, the org design, and the managers under them.
VP	Mgmt · top	The function’s people	Best manager: owns the management chain, org health, and delivery across the whole function.
CTO	apex	The whole product	Best at building product: owns how the company builds, the synthesis of engineering depth and leadership.

The spine down the leverage column is the whole story: task → problem → direction → team → systems (IC) or teams (management), then the whole product at the CTO. “Platformize” is the hinge at Lead and above: you stop doing the work and start building the thing, the systems or the people, that makes it repeatable without you.

Your Shape: The Seven Attributes

The ladder tells you your altitude: one level, how much ambiguity you absorb before you need direction. This tells you your shape: where you are strong, where you are thin, and what to do about it.

It is attribute-focused, not level-focused. You are not “a Mid”. You are a profile: maybe Senior at critical thinking, Junior at delivery, Mid at product sense. Place yourself honestly on each attribute and the line comes out jagged. That jaggedness is the point: it shows exactly where to push next.

It is a mirror, not a scorecard. Nobody is graded or ranked here. Each attribute is a direction to grow, not a number to defend.

Seven attributes make up an engineer’s shape. The first six are the craft and the character; the seventh, leverage, sits near zero early and becomes the whole job at Lead and above.

Product sense: finding and framing the problem worth solving. Impact over output: the instinct to ask “is this the right thing to build?” before “how do I build it?”
Critical thinking: reasoning from first principles to the real cause, past the first plausible answer and backed by data, never pattern-matched. The attribute the hiring loop is built to detect.
Engineering craft: designing the smallest thing that solves the problem and building it well: boring tech, readable output, AI directed to produce it.
Delivery & operations: getting it live safely and knowing it landed. Small PRs behind flags, instrumented and watched; mitigate before investigate.
Communication: being understood the first time, written and verbal. Status that says done, next, blocked; explanations that pre-empt “why?”
Ownership & drive: treating the problem as yours, with the agency to move when blocked and the follow-through to close it.
Leverage: multiplying the people and systems around you. The attribute that separates a strong individual from a force multiplier.

Gauging Someone

You gauge a person by their shape: where they sit on each of the seven attributes, drawn as a radar. Here is every role’s shape, both tracks. Place your report against the role they are growing toward, and the gap is the work.

Every radar below uses these seven spokes in this fixed position. Eight rings mark the eight levels, 1 (Intern) to 8 (CTO); the heavier ring is Lead (5), the floor every senior role holds.

Trunk · the shared climb

Intern

Junior

Mid

Senior

Lead

IC track · depth: leverage through systems

Staff

Principal

Architect

Management track · people: craft recedes, leverage climbs

Manager

Director

Apex · the synthesis

CTO

How to read the shapes. Lead is the floor. Every role above Lead keeps everything a Lead has and extends from there: nothing recedes, and no senior role sits below Lead on any spoke. What differs is which spokes a role pushes past the Lead baseline. The IC track drives the technical spokes (product, critical thinking, craft, delivery) toward the ceiling; the management track drives the people spokes (communication, ownership, leverage). So a Staff and an EM at the same altitude differ in shape, not size, and the most senior roles fill the heptagon. A longer spoke is a different job, not a better person.

Senior: a complete builder, strong across the board, leverage still low.
Lead: the floor for every senior role. Runs a team and owns its delivery, quality, and throughput.
Architect (IC track): pushes the technical spokes to the ceiling; leverage flows through systems and standards.
EM (management track): holds the craft and adds the people. Maxes communication, ownership, and leverage, without dropping below Lead on anything.
CTO: the synthesis, every spoke at the ceiling.

The trunk, in detail

The radar is the summary. For the shared climb up to Lead, here is the same thing in words, attribute by attribute. Past Lead the path forks, so the rows stop at Lead and the shapes above carry it the rest of the way.

Attribute	Intern	Junior	Mid	Senior	Lead
Product sense	Builds what is asked; does not yet weigh whether it is the right thing	Brings a problem they have felt firsthand; needs it framed	Turns a symptom into a sharp problem and checks it is worth solving	Finds the problem worth solving from vague direction; kills low-impact work early	Builds the team’s instinct for impact; sets what “worth solving” means
Critical thinking	Stops at the first plausible cause; repeats the number handed over	Asks “why” to a contributing factor; checks a claim against data	Reaches the system-level cause; backs every claim with real numbers	Reframes when the real cause sits higher up; knows which number would change the call	Coaches it in review; sets what “checked against data” must mean
Engineering craft	Follows the patterns in the codebase; drives AI against explicit criteria	Matches conventions; proposes a workable approach, reviewed	Finds the simple approach; output is consistent and maintainable	Strips to fundamentals, the smallest thing that works; reviews others for correctness	Sets the coding standards and the build-vs-buy defaults
Delivery & operations	Ships a clearly-scoped task; learning the rollout flow	Follows the release plan; small PRs when reminded	Small PRs behind flags, instrumented by default; confirms it is used	Owns the release end to end; mitigates before investigating; nothing surprises anyone	Sets the team’s ship discipline and mitigation playbook
Communication	Updates say “making progress”; narrates what they are doing	Updates say done, next, blocked; walks the approach before coding	Surfaces material changes immediately; explains the tradeoffs	Writes so the reader gets it the first time; reframes to the real point	Sets the team’s communication norms
Ownership & drive	Leaves loose items without an owner; heads-down on their own task	Carries their items to a next action; escalates on scope change	Every thread ends with an owner and a next action; unblocks themselves	Holds themselves to it rigorously; unblocks others; anticipates risk	Holds the team to clear ownership; owns its throughput and quality
Leverage	Focused on their own growth, and that is right for now	Helps peers when asked	The designated reviewer for newer folks	Transfers patterns, not just answers; raises those around them	Grows several engineers deliberately; platformizes how the work gets done

Above the fork, in detail

Past Lead the fork means only some spokes climb, so there is no single column. Lead is the floor: every role above holds all seven spokes at the Lead bar and drives one family to the ceiling — the IC track the four technical spokes, the management track the three people spokes. The other family holds at Lead. Same grid as the trunk, one family at a time. The CTO tops all seven.

Technical spokes — the IC track, Staff → Principal → Architect. On this track the three people spokes hold at the Lead floor.

Attribute	Staff	Principal	Architect
Product sense	Frames what a platform should solve across several teams	Owns the product bets in a domain; decides what is worth building at that scale	Sets the technical-product direction for the whole system
Critical thinking	Diagnoses the recurring failure class behind many incidents, not one bug	The final word on the hardest technical calls in the domain	Reasons about the whole system; right about what is expensive to unwind
Engineering craft	Builds the platform other teams build on; sets the standards and defaults	Designs the hardest components in the domain	Owns the architecture end to end; the bar everyone builds to
Delivery & operations	Makes safe delivery a property of the platform, not a per-team habit	Owns reliability and operability across a domain	Sets how the whole system ships and stays up

People spokes — the management track, Manager → Director → VP. On this track the four technical spokes hold at the Lead floor.

Attribute	Manager	Director	VP
Communication	Aligns a team and up; turns direction into goals people can act on	Aligns across teams and to exec; carries the message both ways	Sets the narrative for the whole function
Ownership & drive	Owns the team’s delivery and each report’s growth	Owns outcomes across several teams and the managers under them	Owns the function’s delivery and health, end to end
Leverage	Grows a team of engineers a level	Grows managers; designs the org so it delivers without them	Multiplies the whole management chain

CTO — the synthesis. Every spoke at the ceiling: the union of engineering depth and leadership, the one best at building product.

Hiring For It

Hiring is two gates, in order. First the non-negotiables: critical thinking, honesty, ownership, low ego, high agency. Fail one and it is a no-hire at any level, no matter the rest. Those, and the interview loop built to force them out, live in Hiring. Then the read: where does the candidate sit on each attribute? The same seven spokes, watched in the room rather than asked about.

Attribute	What to look for in the room
Product sense	Hand them the bare problem and stay quiet: do they probe the real requirement and ask why we are building it, or just execute the prompt?
Critical thinking	Make them re-derive from scratch and slip in a wrong premise: do they catch it, or recite a pattern they cannot justify? This is the core non-negotiable.
Engineering craft	Watch them code their own stated plan: simplest thing first, boring tech, readable without narration?
Delivery & operations	Never ask “did you test it”: the signal is whether they reach for a dry run and edge cases on their own.
Communication	Make them drive the explanation: if you have to ask “why” to follow along, that is a dropped point.
Ownership & drive	Go quiet and inject a blocker: do they state an assumption and push forward, or stall until led?
Leverage	Hard to screen below Senior; at Senior and above, ask how they have made specific people better, with evidence. Lead and above is a leadership loop, run per Hiring.

You hire at the level the evidence supports, attribute by attribute, not the level on the CV. A spiky candidate is normal: hire the spikes you need and coach the rest, but never past a failed non-negotiable.

Growing Your Reports

This is the part that compounds. A direct report’s profile is your coaching agenda, and the move is almost always the same two:

Double down on the spike. The attribute they are already strongest at is usually where their value compounds fastest. Feed it.
Clear the one blocker. Find the single thinnest spoke holding them below their next altitude and put real reps there. A rounded-but-flat profile helps no one; do not sand the spikes down to raise the floor everywhere at once.

The mechanism per attribute is the same: have them apply the next level’s behavior one step earlier than feels comfortable, then close the gap with review.

Attribute	The rep that levels it up
Product sense	Own Discover on a real problem before it is framed; sit in one “should we even build this?” call
Critical thinking	Make them re-derive in review; ask “what number would change your mind”, then have them go and get it
Engineering craft	Challenge them to deliver the same outcome with half the parts; put them on reviewing someone else’s output for correctness
Delivery & operations	Give them a rollout to own end to end, flag and instrumentation included; walk them through one real mitigation
Communication	Hand them the update others rely on; rewrite it together until no one has to ask “why”
Ownership & drive	Give them something underspecified and stay quiet; let them drive it to done
Leverage	Make them the reviewer or mentor; give them one person’s growth to actually own

Where growth goes exponential. Early on, you grow a report’s own spokes. As they approach Lead, the highest-leverage move flips: their growth becomes growing their reports’ spokes. That is the seventh attribute taking over, and it is the difference between adding one person’s output and lifting everyone’s. A lead who raises three engineers a level has done more than the best individual contributor ever could.

Keep it live: the profile is the spine of the 1:1, revisited each cycle, and updates are where you watch a spoke actually move. For how to run the growth conversation itself, see Leading People.

Related: Roles, Hiring, Leading People