A Software Engineering Career Ladder

I’ve been quiet lately, and that’s because I’ve joined OpenSesame as Vice President of Engineering. It’s been a fascinating opportunity to rebuild an engineering organization from the inside, and I’m loving every minute. We’re introducing a lot of cutting-edge software development practices, such as self-organizing vertically-scaled teams and Extreme Programming.

As you might expect, introducing these changes to an organization with [REDACTED] number of engineers has been challenging. (I’m not sure if I’m allowed to say how many engineers we have, so let’s just say “lots,” but not “tons.” Bigger than a breadbox, anyway. Enough that I don’t do any coding myself, and the managers that report to me don’t have time to do much either.)

What I’m really doing is changing the engineering culture at OpenSesame. Culture doesn’t change easily. It tends to snap back. True change involves changing hundreds of little day-to-day decisions. That’s hard, even when people want to make those changes, and full buy-in is hard to come by. I’ve hired several XP coaches to help, but even they’re stretched thin.

A Lever for Change

This is where the new career ladder comes in. OpenSesame had a pretty innovative approach to career development before I joined. It involved a spreadsheet where engineers would gather evidence of their skills. Each piece of evidence contributed towards an engineer’s promotion. It did a nice job of being objective (or at least, as objective as these things can be) and clear about expectations.

The new career ladder builds on the ideas of the previous spreadsheet to introduce the changes I want. Where the old spreadsheet focused on individual ownership and investigating new technologies, the new one emphasizes teamwork, peer leadership, and maintainable code. I’m hoping this will help direct people to new behaviors, which will in turn start to change the engineering culture.

The new spreadsheet also replaces the previous evidence-based approach with a simple manager-led evaluation of skills. This makes room for a lot more skills. Too many, possibly. It’s a very fine-grained approach. But I’m hoping that will help provide clarity to engineers and give them the opportunity to pick and choose which skills they want to work on first.

How It Works

Each title has certain skill requirements, which are grouped into skill sets. For example, “Software Engineer” requires these skill sets:

  • Basic Communication
  • Basic Leadership
  • Basic Product
  • Basic Implementation
  • Basic Design
  • Basic Operations

Each skill set includes several skills. For example, “Basic Design” includes these skills:

  • Decompose problem into tasks
  • Class abstraction
  • Mental model of your team’s codebase
  • Mental model of a complex dependency
  • Campsite rule
  • Fail fast
  • Paranoiac telemetry
  • Evaluate simple dependencies

(There’s a document that explains each skill in more detail.)

Managers evaluate each engineers’ skills by talking to team members and observing their work. Each skill is graded on this scale:

  • None. The engineer doesn’t have this skill.
  • Learning. The engineer is learning this skill.
  • Proficient. The engineer can succeed at the skill when they concentrate on it, but it isn’t second nature.
  • Fluent. The engineer uses the skill automatically, without special effort, whenever it’s appropriate.

When an employee is fluent at all the skills for a particular title (and all previous titles), they’re eligible for promotion to that title.

(We also offer step promotions, such as Software Engineer 1 to Software Engineer 2, which come when the engineer is proportionally far along their way to the next title.)

Submitted for Your Approval

Why tell you all this? Because I want your feedback. We have an early draft that we’re starting to roll out to a handful of engineers. I’m sure there are opportunities for improvement. We’ve probably forgotten some skills, or set the bar too high in some areas, or too low.

So I’d love for you to take a look and share what you think. Maybe you’ll find some of the ideas useful for your own teams, too. You can find the spreadsheet and documentation here:

Please share your feedback in one of these places:

Full Career Ladder

Here’s the full list of titles and skills. You can find descriptions of each skill in the documentation.

Associate Software Engineers

Associate Software Engineer 1s are at the start of their career. They’re expected to understand the basics of software development, and be able to work in a professional setting, but they’re mostly working under the guidance of more experienced engineers.

  • Professionalism

    • Spoken and written English
    • Work ethic
    • Intrinsic motivation
    • Remote attendance
    • In-person attendance
    • Active participation
    • Respectful communication
    • Transparency
    • Team orientation
    • Follow the process
    • Grit
    • Absorb feedback
    • Growth mindset
    • OpenSesame Qualified1
  • Classroom Engineering

    • Object-oriented programming language
    • Pairing/teaming driver
    • Classroom-level debugging
    • Function and variable abstraction

1“OpenSesame Qualified” is our internal training program.

Software Engineers

Software Engineer 1s still have a lot to learn, but they’re able to contribute to the work of their team without explicit guidance. They’re beginning to demonstrate peer leadership skills and develop their abilities as generalizing specialists.

  • Basic Communication

    • Collective ownership
    • Defend a contrary stance
    • “Yes, and...”
    • Try it their way
    • Technical feedback
    • Active listening
    • As-built documentation
  • Basic Leadership

    • Basic facilitation
    • Team steward
    • Valuable increment steward
    • Scut work
  • Basic Product

    • Your team’s product
    • Your team’s customers and users
    • User story definition
  • Basic Implementation

    • Your team’s programming language
    • Your team’s codebase
    • Basic test-driven development
    • Sociable unit tests
    • Narrow integration tests
    • End-to-end tests
    • Manual validation
    • Spike solutions
    • Basic SQL
    • Pairing/teaming navigator
    • Basic algorithms
    • Basic performance optimization
    • Debugging your team’s components
    • Simple dependency integration
    • Unhappy path thinking
  • Basic Design

    • Decompose problem into tasks
    • Class abstraction
    • Mental model of your team’s codebase
    • Mental model of a complex dependency
    • Method and variable refactoring
    • Campsite rule
    • Fail fast
    • Paranoiac telemetry
    • Evaluate simple dependencies
  • Basic Operations

    • Source control
    • Your team’s release process
    • On-call responsibility
    • On-call triaging
    • Issue investigation
    • Your team’s cloud infrastructure
    • Code vulnerability awareness
    • Cloud vulnerability awareness

Senior Software Engineers

Despite the name, Senior Software Engineer 1s are still fairly early in their careers. However, they have enough experience to take a strong peer leadership role in their teams. They’ve developed broader generalist skills and deeper specialist skills.

  • Advanced Communication

    • Clear and concise speaking
    • Clear and concise writing
    • Technical diagramming
    • Explain mental model
    • Ensure everyone’s voice is heard
    • Coalition building
    • Interpersonal feedback
    • Runbook documentation
  • Advanced Leadership

    • Peer leadership
    • Comfort with ambiguity
    • Risk management
    • Intermediate facilitation
    • Mentoring and coaching
    • Critique the process
    • Circles and soup
  • Advanced Product

    • Ownership
    • Vertical slices
    • Cost/value optimization
  • Advanced Implementation

    • All of your team’s programming languages
    • All of your team’s codebases
    • Codebase specialty
    • Code performance optimization
    • Complex dependency integration
    • Retrofitting tests
    • Exploratory testing
  • Advanced Design

    • Codebase design
    • Simple design
    • Reflective design
    • Cross-class refactoring
    • Basic database design
    • Mental model of team dependencies
    • Evaluate complex dependencies
    • Simplify and remove dependencies
  • Advanced Operations

    • Observability
    • Basic build automation
    • Basic deployment automation
    • Incident leader
    • Incident communicator
    • Incident fixer
  • Senior SE Specialty

    • Choose one of the specialty skill sets listed below.

Technical Leads

Technical Leads are the backbone of a team. They combine deep expertise in several specialties with the ability to mentor and coach less experienced team members. They work closely with the team’s other technical leads to advise engineering managers on the capabilities and needs of the team. However, this remains a coding-centric role, and the majority of their time is spent as a player-coach working alongside other team members.

  • Team Leadership

    • Personal authority
    • Leaderful teams
    • Leadership specialty
    • Assess technical skills
    • Assess interpersonal skills
    • Assess product skills
    • Technical interview
    • Impediment removal
  • Interpersonal Leadership

    • Humility
    • Psychological safety
    • Calm the flames
    • Ignite the spark
  • Product Leadership

    • Options thinking
    • Status and forecasting
    • Progress and priorities
  • Design Leadership

    • Simple codebase architecture
    • Reflective codebase architecture
    • Risk-driven codebase architecture
    • Architectural refactoring
    • Published API design
  • Technical Lead Specialties

    • Choose three(?) additional specialty skill sets.

Staff Engineers

Staff Engineers make a difference to the performance of Engineering as a whole. They rove between teams, cross-pollinating information and ideas. They work hands-on with each team, acting as player-coaches, bringing a breadth and depth of expertise that people are happy to learn from.

These skill sets haven’t been defined yet.

Principal Engineers

This level hasn’t been defined yet.

Specialty Skill Sets

Starting at the Senior Software Engineer level, engineers choose specialty skill sets in additional to the foundational skill sets described above. We haven’t defined these skill sets yet, but here are some of the ones we’re considering:

  • Product
  • Distributed systems
  • Databases
  • Security
  • Extreme Programming
  • Developer Automation
  • Algorithms
  • Machine Learning
  • Front-End
  • iOS
  • Android


Please share your thoughts!

If you liked this entry, check out my best writing and presentations, and consider subscribing to updates by email or RSS.