Skip to content
The Growth Track
← All articles
  • Career ladders
  • Engineering levels

Software engineering levels: from Junior to Principal

What actually changes between junior, mid-level, senior, staff and principal engineers, and how to write level expectations your team can use.

Rachid Baaziz

· 4 min read

Job titles like Senior Engineer or Staff Engineer mean very different things from one company to the next. Inside your company, they should mean exactly one thing. This article describes what typically changes from level to level on an individual contributor track, so you can define your own.

The levels below follow a five-step structure (L1 to L5). Your names and boundaries may differ; what matters is that each step is clearly different from the one before.

What changes as engineers grow

Across almost every engineering ladder, four things grow from one level to the next:

  • Scope: from a task, to a feature, to a system, to several teams, to the organization.
  • Autonomy: from needing guidance, to working independently, to setting direction for others.
  • Ambiguity: from well-defined problems, to problems where defining the problem is part of the job.
  • Influence: from their own work, to their team, to people they don't manage.

Technical skill grows too, but it rarely separates levels on its own. A brilliant engineer who only works on well-scoped tasks is not yet operating at a senior level.

L1: Junior Engineer

A junior engineer delivers well-scoped tasks with guidance and asks for help when blocked. They write tested, readable code, respond to review feedback, and learn the team's practices.

What good looks like: steady progress on assigned work, fast learning, and openness to feedback.

Ready for the next level when: they deliver small features end to end with little help, and their questions shift from how to why.

L2: Software Engineer

The engineer delivers features end to end with little guidance and owns them in production, including monitoring and fixing what breaks. They design components that fit the existing architecture and help onboard new teammates.

What good looks like: reliable delivery, code that is easy to change, and clear communication about progress and trade-offs.

Ready for the next level when: they take ambiguous projects and turn them into a plan the team can execute.

L3: Senior Engineer

A senior engineer breaks down ambiguous projects into milestones and delivers them predictably. They design and own technical solutions for medium-sized systems, reason about failure modes, performance and cost, and raise the quality bar of the team through reviews and better practices. They mentor other engineers.

What good looks like: the team ships better because they are on it, not only because of the code they write.

Ready for the next level when: their impact regularly reaches beyond their own team.

Senior is often the level where engineers can stay for a long, successful career. A healthy ladder makes that explicit: staff and principal are different jobs, not a reward for time served.

L4: Staff Engineer

A staff engineer drives multi-team initiatives to completion and owns cross-cutting technical problems that no single team is accountable for. They design systems that span several teams and stay sound as they grow, and they build alignment through written proposals and discussion.

What good looks like: hard, cross-team problems get solved, and other engineers become more effective around them.

Ready for the next level when: they shape technical direction at the level of the whole organization.

L5: Principal Engineer

A principal engineer defines the target architecture of the platform and guides its evolution. They anticipate how technology and business changes will affect it, shape the engineering practices of the whole organization, and develop its technical leadership.

What good looks like: long-term technical outcomes for a product line or the company, and a stronger bench of technical leaders.

Writing level expectations that work

When you write your own levels, a few rules keep them usable:

  1. Write per area, not per level. Instead of one long paragraph per level, write one or two sentences for each area at each level. Readers can then compare levels line by line.
  2. Keep the same areas across levels. What changes is the expectation, not the list.
  3. Make the jump between levels visible. Reading L2 and L3 for the same area side by side should make the difference obvious.
  4. Use the language of outcomes and scope. "Owns a service and improves its health" is assessable; "is highly proactive" is not.

Using levels day to day

Levels earn their keep outside of promotion discussions:

  • Placement: every engineer knows their current track and level.
  • Goals: growth goals can point at specific expectations of the next level.
  • Reviews: self, peer and manager feedback refers to the same expectations, so a review becomes a conversation about evidence rather than impressions.

When levels are used this way all year round, promotion decisions stop being surprises, for the engineer and for the manager.

  • · 5 min read

    How to build a software engineering career ladder

    A practical, step-by-step guide to defining tracks, levels, areas and expectations for engineers, without writing a 40-page document nobody reads.

    • Career ladders
    • Engineering management