Library
Software engineer career path, levels and ladder
Updated
5 levels, from Junior Software Engineer to Principal Software Engineer. Each one is rated on the same 39 skills — what changes between the rungs is how good you have to be at each. An engineer ladder from junior to principal, covering development, testing, system design, operations, security and data.
- Level 1 of 5
Junior Software Engineer job description
Delivers well-scoped tasks with review and regular guidance.
Read the job description - Level 2 of 5
Mid Software Engineer job description
Owns whole features end to end with little day-to-day direction.
Read the job description - Level 3 of 5
Senior Software Engineer job description
Leads delivery of a system and raises the bar for the team.
Read the job description - Level 4 of 5
Lead Software Engineer job description
Sets technical direction across teams and unblocks their work.
Read the job description - Level 5 of 5
Principal Software Engineer job description
Shapes engineering strategy and the hardest calls org-wide.
Read the job description
Software engineer levels and job titles
Companies give the same levels different names. This table maps each level on this ladder to the titles and level labels you will commonly see elsewhere. For how these titles line up across departments, see the job title hierarchy.
| Level on this ladder | Common job titles | Typical level labels |
|---|---|---|
| Junior Software Engineer | Junior Software Engineer, Software Engineer I, Associate Software Engineer | Engineer I, L3 |
| Mid Software Engineer | Software Engineer, Software Engineer II | Engineer II, L4 |
| Senior Software Engineer | Senior Software Engineer, Software Engineer III | Engineer III or Senior, L5 |
| Lead Software Engineer | Lead Software Engineer, Tech Lead, Staff Software Engineer | Staff, L6 |
| Principal Software Engineer | Principal Software Engineer, Senior Staff Engineer, Software Architect | Senior Staff or Principal, L7–L8 |
Individual contributor or manager?
All five levels here are individual contributor (IC) levels. Each rung is rated on a wider technical scope, with leadership and mentoring growing alongside, but no rung is rated on managing people. Many companies also run a manager track that branches off around Senior: Engineering Manager, then Senior Engineering Manager and Director of Engineering. Moving between the two tracks is a change of job, not a promotion. In many companies a Staff or Principal engineer sits at the same level as a manager, without having reports.
Skills matrix
39 skills across 5 levels.
| Skill/Certification 39 | Junior | Mid | Senior | Lead | Principal |
|---|---|---|---|---|---|
| Software Development7 | |||||
| BasicYou can design, write, test and document a small program or script from a written specification, working under direction. Your changes pass review with minor comments, and you follow the build and packaging steps without needing them explained again. | ProficientYou can take a medium-complexity feature from specification to production on your own, choosing appropriate structures and tools, and you document it so someone else can maintain it. You raise gaps in the specification before writing code rather than after. | AdvancedYou can set the programming conventions your team follows, including for changes of high technical complexity. | AdvancedYou can set the programming conventions your team follows, including for changes of high technical complexity. | ExpertYou can advise the organization on which technical standards to adopt or retire. | |
| BasicYou can explain the main principles behind the team development standards and apply them to your own work once someone points you at the right practice for the situation. | ProficientYou can apply the team standards without prompting and help a colleague adopt them. You notice when a shortcut is being taken and say so in review rather than after release. | AdvancedYou can apply modern development standards to complex multi-team work and lead others in adopting them. When you make a deliberate exception you write down the tradeoff you accepted. | AdvancedYou can apply modern development standards to complex multi-team work and lead others in adopting them. When you make a deliberate exception you write down the tradeoff you accepted. | ExpertYou can decide which development standards the organization adopts, pilots or retires, and show evidence of the effect on delivery. You change practice in teams you do not manage by persuasion rather than mandate. | |
| BasicYou can review routine changes in your team codebase, spot missing tests and error handling, and separate a blocking objection from a preference. You take review on your own work without defensiveness. | ProficientYou can review changes in areas you do not own and catch design problems, not only style. Your comments are specific and actionable, and your turnaround is short enough that review does not become the bottleneck. | AdvancedYou can review high-risk changes such as data migrations, security-relevant code and cross-team interfaces, and you set what the review bar is for your team. You coach reviewers whose feedback is vague or discouraging. | AdvancedYou can review high-risk changes such as data migrations, security-relevant code and cross-team interfaces, and you set what the review bar is for your team. You coach reviewers whose feedback is vague or discouraging. | ExpertYou can shape how review works across the organization, including what must be reviewed, by whom, and where review should be replaced by a stronger control. | |
| BasicYou can diagnose defects in code you work on regularly, form a hypothesis before changing anything, and confirm a fix by reproducing the original failure and watching it stop. | ProficientYou can diagnose failures in unfamiliar code and across process boundaries using traces, metrics and bisection. You find the cause rather than a symptom, and you write down what you found. | AdvancedYou can lead diagnosis of intermittent and production-only failures that have already defeated others, and you decide when to stop investigating and mitigate instead. You then improve the tooling that made it hard. | AdvancedYou can lead diagnosis of intermittent and production-only failures that have already defeated others, and you decide when to stop investigating and mitigate instead. You then improve the tooling that made it hard. | ExpertYou can diagnose failures that cross system and organizational boundaries, and you drive the changes that make whole classes of defect either diagnosable or impossible. Teams escalate to you as the last resort. | |
| NoviceYou can rename, extract a function and delete dead code safely when a reviewer or a test suite confirms the behavior is unchanged. | ProficientYou can restructure a component with poor boundaries while it stays in production, releasing each step on its own, and explain when a refactor is not worth doing. | AdvancedYou can plan and land a structural change across several components, keeping it reversible and visible to the teams affected. You argue for the work in terms of delivery cost rather than taste. | AdvancedYou can plan and land a structural change across several components, keeping it reversible and visible to the teams affected. You argue for the work in terms of delivery cost rather than taste. | ExpertYou can set how the organization pays down structural debt, including which systems get investment and which get replaced or deliberately left alone, and call off an expensive rewrite. | |
| BasicYou can keep a tidy local history, write commit messages that explain why, resolve routine conflicts yourself, and recover from a mistake with revert or reflog rather than starting the work again. | ProficientYou can use history as a diagnostic tool through bisect, blame and cherry-pick, and you keep a large change reviewable by splitting it into a series. You recover from a bad merge without losing work. | AdvancedYou can define the branching and release workflow your team uses and explain the tradeoffs it makes. You handle the situations others avoid, such as a rewritten shared branch or a secret committed to history. | AdvancedYou can define the branching and release workflow your team uses and explain the tradeoffs it makes. You handle the situations others avoid, such as a rewritten shared branch or a secret committed to history. | AdvancedYou can define the branching and release workflow your team uses and explain the tradeoffs it makes. You handle the situations others avoid, such as a rewritten shared branch or a secret committed to history. | |
| NoviceYou can add an endpoint or method that follows the patterns already in the codebase, and you can read an API specification and say what a given call will return. | BasicYou can design a small interface and write its specification before implementing it. | ProficientYou can design the interface for a whole service, including pagination, idempotency, versioning and error semantics, and evolve it without breaking existing callers. You gather real caller needs first. | AdvancedYou can design interfaces used across team boundaries, negotiate them with their consumers, and set your team conventions and deprecation policy. You can judge when a breaking change is worth its migration cost. | ExpertYou can set API standards for the organization, including how long compatibility guarantees hold, and arbitrate between teams with conflicting interface needs. You design the interfaces that outlive their systems. | |
| Testing and Quality4 | |||||
| BasicYou can select suitable test types for routine work with some support, and design cases covering the happy path, the boundaries and the obvious error paths. You set up a test environment when shown how. | ProficientYou can decide what to test and at which level, choosing techniques that find defects early rather than repeating coverage that already exists. You guide others and set up your own environments and data. | AdvancedYou can shape the test approach for a whole product, influencing technique choice across teams so risk is mitigated as early as possible. You coach others and prune tests that no longer earn their runtime. | AdvancedYou can shape the test approach for a whole product, influencing technique choice across teams so risk is mitigated as early as possible. You coach others and prune tests that no longer earn their runtime. | ExpertYou can set organizational standards for test types, techniques and coverage, and show which risk each one addresses. You drive continuous refinement of how testing is done rather than defending the current suite. | |
| BasicYou can use the team frameworks and tooling to write reliable automated tests, and wire them into continuous integration so they run on every change. You fix the flaky tests you introduce. | ProficientYou can build and extend reusable test frameworks, fixtures and helpers that other engineers actually adopt, and you keep total suite runtime and flake rate under control. You coach others in writing tests worth keeping. | AdvancedYou can set the automation strategy for a product, deciding what runs where, on what trigger, and what blocks a release, and you evaluate tooling against real needs rather than novelty. | AdvancedYou can set the automation strategy for a product, deciding what runs where, on what trigger, and what blocks a release, and you evaluate tooling against real needs rather than novelty. | AdvancedYou can set the automation strategy for a product, deciding what runs where, on what trigger, and what blocks a release, and you evaluate tooling against real needs rather than novelty. | |
| NoviceYou can fix a performance problem someone else has located, such as an oversized image or a missing index. | BasicYou can profile the code you changed to find its slowest step. | ProficientYou can trace a missed performance budget to its cause. | AdvancedYou can set the performance budgets a product ships against. | ExpertYou can set how the organization monitors performance, including which measures come from real users. | |
| NoviceYou can explain that users have different access needs, and you can fix an accessibility defect that someone else has flagged, under direction. | BasicYou can build interfaces that meet the required accessibility standard and check them with an automated tool and with the keyboard alone, fixing what you find under direction. | ProficientYou can test an interface against a defined standard using a screen reader and manual checks rather than automated tooling alone, and you give design feedback early enough to avoid a failure at audit. | AdvancedYou can set the accessibility bar for a product and the checks that enforce it, champion it with internal stakeholders, and judge which findings are genuine barriers rather than tool noise. | AdvancedYou can set the accessibility bar for a product and the checks that enforce it, champion it with internal stakeholders, and judge which findings are genuine barriers rather than tool noise. | |
| Systems and Design6 | |||||
| NoviceYou can read an existing design document and explain what the components are for and where they hand off to each other. You can draw the current shape of a system you work in without leaving out the parts you find confusing. | BasicYou can design a single component to a specification someone else has set, choosing structures that fit the constraints you were given. You write the design down before you build it and you take feedback on it. | AdvancedYou can design systems spanning several components and teams where the requirements are still contested, and you set the design approach others follow. You size the design to the need rather than to the most interesting version of it. | AdvancedYou can design systems spanning several components and teams where the requirements are still contested, and you set the design approach others follow. You size the design to the need rather than to the most interesting version of it. | ExpertYou can set the design direction for systems the whole organization depends on, judge whether a proposed design is worth building, and argue for the simpler option. | |
| NoviceYou can trace a call from one system into another and say what data crosses the boundary. You can run an existing integration test and read what it reports while someone works alongside you. | BasicYou can build and test an integration against a documented interface under direction, handling the error responses that interface defines. You check the behavior against a real instance of the other system rather than only a mock. | ProficientYou can identify the connection points a piece of work needs and get an integration into production, including timeouts, retries and reconciliation. You test the failure paths as deliberately as the successful one. | AdvancedYou can lead integration across systems owned by different teams or suppliers, negotiating both the contract and the cutover plan. You surface the assumptions each side has made about the other before they cause an outage. | ExpertYou can set how systems across the organization are connected, including which integration patterns are standard and which are being retired, and you resolve disputes between teams. You can say when two systems should not be joined at all. | |
| NoviceYou can find the record behind a past technical decision and explain what was chosen, what was rejected and why. | BasicYou can record a decision you made on your own work, naming the option you took and at least one you did not. You escalate a decision that reaches beyond the code you own rather than settling it quietly. | ProficientYou can make and document decisions that shape a service, setting out the alternatives, the risks and what would make you revisit the choice. You involve the people affected while the decision is still open. | AdvancedYou can take decisions that bind several teams under real uncertainty, and you make the tradeoff visible instead of presenting the outcome as obvious. You reopen a decision when the evidence changes and say publicly that you have. | ExpertYou can set which decisions need recording across the organization, who takes them and how they are reviewed, and settle choices where two teams each have a defensible answer. | |
| NoviceYou can read a schema and explain what each table holds and how the tables relate. You can write a simple query and, with help, tell whether the result answers the question that was actually asked. | ProficientYou can design the data structures for a feature with the right keys, constraints and indexes, and write migrations that change a live schema without downtime. You read a query plan rather than guessing at why something is slow. | AdvancedYou can design the data model for a whole service, including how it will evolve, and you set the schema conventions your team works to. You correct the query patterns that will not scale before the data volume proves it. | AdvancedYou can design the data model for a whole service, including how it will evolve, and you set the schema conventions your team works to. You correct the query patterns that will not scale before the data volume proves it. | ExpertYou can set data modeling and query standards across the organization, including which stores serve which purpose and how irreversible migrations are reviewed. | |
| NoviceYou can build a small throwaway example to answer a question someone else has framed, and report what you found. You leave the code as an experiment rather than trying to turn it into production work. | BasicYou can run a time-boxed spike on a defined unknown and write up what you learned, including the part you failed to answer. You stop at the time box instead of polishing code that will be discarded. | ProficientYou can decide what to prototype when a design is uncertain and pick the cheapest experiment that settles the question. You state the question before you start, so the result is an answer rather than an impression. | AdvancedYou can use prototypes to take risk out of complex work, and you set how far a spike runs before the team commits to a direction. You are willing to report that the prototype disproved the option you preferred. | AdvancedYou can use prototypes to take risk out of complex work, and you set how far a spike runs before the team commits to a direction. You are willing to report that the prototype disproved the option you preferred. | |
| NoviceYou can describe who uses the software your team builds and what they are trying to do, using the user stories on the backlog. | BasicYou can trace a ticket back to the user need behind it and check your change against that need before you hand it over. | ProficientYou can choose between ways of building a feature using usage data and user feedback, stating the user impact of each. | AdvancedYou can represent users in cross-team technical decisions and challenge plans that would make the product harder to use. | AdvancedYou can represent users in cross-team technical decisions and challenge plans that would make the product harder to use. | |
| Operations and SRE5 | |||||
| NoviceYou can push a change through the existing pipeline, read a failed stage and say which step broke. You ask first before doing anything by hand that the pipeline is meant to do. | ProficientYou can build a pipeline that takes a change from commit to production through automated checks, and you keep releases small and reversible. You can roll a release back under pressure without improvising. | AdvancedYou can design the delivery approach for a product, covering how changes are gated, released progressively and rolled back. | AdvancedYou can design the delivery approach for a product, covering how changes are gated, released progressively and rolled back. | ExpertYou can set delivery practice across the organization, including what evidence a release needs, and show the effect on lead time and failure rate. You hold the line on small frequent releases when a team wants to batch them. | |
| NoviceYou can find the logs and dashboards for a service and use them to answer a simple question about what it is doing. You can add a log line where a reviewer suggests one. | BasicYou can add logs and metrics to the code you write and set up a straightforward alert under direction. | ProficientYou can decide what a service needs to expose for its behavior to be visible, then build the dashboards and alerts. Your alerts fire on user impact rather than on every anomaly, and you add tracing when logs alone cannot follow a request. | AdvancedYou can set the observability approach for a product, retire the alerts that wake people for nothing, and make sure a new service ships instrumented instead of gaining it after an incident. You use the data to argue for engineering work. | ExpertYou can set observability standards and tooling across the organization, including what every service must emit, and bring the cost of that data down without losing what matters. | |
| NoviceYou can follow the incident process, keep a record of what you tried and hand over cleanly at the end of your shift. You escalate early rather than working alone on something you cannot yet judge. | BasicYou can take a defined role in an incident, carry out an agreed mitigation and report status in plain terms, changing only what the incident lead approves. | ProficientYou can lead the response to an incident on your own service, choosing between mitigation and a fix and updating affected people, then write follow-up actions with named owners. | AdvancedYou can lead a severe or unclear incident across several teams and keep the investigation ordered when there is pressure to start guessing. You decide when a partial mitigation is enough, and you run reviews that produce change rather than blame. | ExpertYou can set how the organization responds to incidents, including severity, escalation and what a follow-up must produce. You read the pattern across incidents and use it to argue for the structural work that prevents the next one. | |
| NoviceYou can explain what an availability target means for a service and where its current numbers are reported. You can see that a resource is near a limit once someone has shown you where to look. | BasicYou can watch a service against its targets, flag when headroom is shrinking and carry out an agreed scaling change. You can say which of your own changes add load to a system. | ProficientYou can keep a service inside its agreed targets, forecast demand from real usage and provision for it before it bites. You design single points of failure out of the parts of the system you own. | AdvancedYou can agree availability targets with the business and design a product that holds them, weighing redundancy against cost honestly. You plan for the demand events others treat as unlikely, and you test that the plan works. | ExpertYou can set how the organization defines, funds and reports reliability, and arbitrate between availability and delivery speed. You say plainly when a target costs more than the risk it removes. | |
| NoviceYou can read the infrastructure definitions for a service and say what they create. You can make a small parameter change and get it reviewed and applied with support. | BasicYou can write and change infrastructure code for routine resources, run a plan and read what it says will change before you apply it. You keep changes in version control instead of adjusting a console by hand. | ProficientYou can provision a service and its environments entirely in code, structure the modules so environments stay consistent, and handle state and secrets safely. You can rebuild an environment from the repository alone. | AdvancedYou can design the infrastructure codebase for a product, set the patterns other teams reuse and bring manually built resources back under code. You keep a risky change reviewable by making the plan small enough to read. | AdvancedYou can design the infrastructure codebase for a product, set the patterns other teams reuse and bring manually built resources back under code. You keep a risky change reviewable by making the plan small enough to read. | |
| Security and Data3 | |||||
| NoviceYou can name the common classes of vulnerability that affect the code you write and fix one that a reviewer or a scanner has flagged. You ask for help before writing credential or authentication handling yourself. | BasicYou can apply the standard controls in your own code, validating input, encoding output and using the platform authentication and authorization rather than inventing your own. You raise a security concern in review instead of assuming someone else saw it. | ProficientYou can build a feature that holds up against realistic abuse, thinking through what an attacker would try and treating authorization as a design question rather than a late addition. You work through scanner findings by severity, not by ease. | AdvancedYou can threat model a system with the team, set the security bar for the product and make sure high-risk changes get a real review. You can tell a genuine risk from tool noise and explain which one you are looking at. | ExpertYou can set security engineering practice across the organization, decide which controls are mandatory, work with security specialists on product risks, and judge whether a residual risk is acceptable. | |
| NoviceYou can tell personal data apart from other data in a system you work on, and you follow the rules on what may be copied, logged or displayed. You ask before moving data out of an environment. | BasicYou can handle personal data correctly in the code you write, collecting only what is needed and keeping it out of logs and test fixtures. You apply the retention and access rules once someone has shown you which ones apply. | ProficientYou can design a feature so its data is classified, minimized, kept for a stated period and reachable only by people who need it. You can satisfy a deletion or subject access request from the system without a manual hunt. | AdvancedYou can set how a product handles sensitive data, work with legal and privacy colleagues on the obligations, and build controls that make compliance provable rather than asserted. You find the data flow nobody wrote down. | AdvancedYou can set how a product handles sensitive data, work with legal and privacy colleagues on the obligations, and build controls that make compliance provable rather than asserted. You find the data flow nobody wrote down. | |
| NoviceYou can add a library the team already uses, explain what a lock file is for and find which version a project depends on. You ask before introducing something new. | BasicYou can add, upgrade and remove dependencies for your own work, read a changelog for breaking changes and act on a vulnerability alert under direction. You check that a library is maintained before you reach for it. | ProficientYou can judge whether a dependency earns its cost against writing the code yourself, keep a project current instead of letting upgrades pile up, and land a major version bump without breaking callers. You delete what is no longer used. | AdvancedYou can set how a product takes on and retires dependencies, plan an upgrade that touches many services and handle a supply-chain advisory quickly and calmly. You get a stuck legacy dependency moving rather than recording it as permanent. | AdvancedYou can set how a product takes on and retires dependencies, plan an upgrade that touches many services and handle a supply-chain advisory quickly and calmly. You get a stuck legacy dependency moving rather than recording it as permanent. | |
| Delivery4 | |||||
| NoviceYou can keep your own tasks and deadlines in a current to-do list, and tell your manager as soon as work you own will be late. | BasicYou can organize a small piece of work into steps, put them in a sensible order, and finish it by the date you agreed, raising problems before they cause a delay. | ProficientYou can coordinate a small team's work on a shared goal: who does what by when, what has to wait for what, and a revised plan when things change. | AdvancedYou can keep several people's work in step across teams, agree priorities and hand-offs with them, and keep one shared task list that all of them actually use. | ExpertYou can set the everyday habits for how work is organized and followed up across the organization, and teams you do not lead adopt the routines you introduce. | |
| NoviceYou can estimate how long a task will take once the approach is clear, and you say promptly when the estimate turns out to be wrong. | BasicYou can estimate your own work with reasonable accuracy and keep a steady enough pace that other people can plan around you. | ProficientYou can estimate a whole project including its risks and unknowns, split it into stages, and defend the estimate when it is challenged. | AdvancedYou can estimate work that spans several teams, name the assumptions behind each figure, and rework the plan when those assumptions break. | ExpertYou can forecast work and staffing quarters ahead, and set the estimating method other teams use. | |
| BasicYou can stay responsible after you hand work over: you check it did what it was meant to, fix your own mistakes, and give updates before anyone asks. | ProficientYou can pick up a problem that has no obvious owner and make yourself accountable for it, including the parts nobody enjoys. | AdvancedYou can hold accountability for outcomes delivered mostly by other people, taking the blame when it fails and passing on the credit when it works. | AdvancedYou can hold accountability for outcomes delivered mostly by other people, taking the blame when it fails and passing on the credit when it works. | ExpertYou can report the organization's most exposed outcomes to its leaders as they stand, including bad news, and answer for them. | |
| BasicYou can choose checks that suit the task in front of you, catch your own mistakes before anyone else sees them, and confirm the result works once people start using it. | ProficientYou can define what good enough means for a project, put checks in place to show it has been met, and hold work back when it falls short. | AdvancedYou can set how quality is checked on complex work shared by several teams, and you spot the problems that only appear where their pieces meet. | AdvancedYou can set how quality is checked on complex work shared by several teams, and you spot the problems that only appear where their pieces meet. | ExpertYou can raise the quality bar across the organization by building the tools and habits that make the careful way the easy way. | |
| Craft3 | |||||
| BasicYou can work out what is wrong in work you did not create, and you fix the underlying cause instead of working around the symptom. | ProficientYou can break a large, ambiguous problem into pieces and weigh the options for each against the evidence. | AdvancedYou can make the call on a problem outside your expertise and explain its cost, time and risk. | AdvancedYou can make the call on a problem outside your expertise and explain its cost, time and risk. | ExpertYou can crack problems the organization has repeatedly failed to solve, and your approach becomes how others tackle that whole kind of problem. | |
| NoviceYou can apply the basics of your field to the work you are given, and ask an expert when a task goes beyond what you have learned. | BasicYou can work confidently with the tools and methods your team uses daily, and you can explain how your work serves the team's goals. | ProficientYou can advise the team on your area and apply new developments in the field where they pay off. | AdvancedYou can bring in good practice from outside the organization and make it work here, and your judgment clearly improves the work you touch. | ExpertYou can influence how the field is practiced beyond this organization, and your expertise settles questions that have stood open for years. | |
| ProficientYou can pick up an unfamiliar area fast enough to be useful in it, and you turn what you learned into something others can reuse. | ProficientYou can pick up an unfamiliar area fast enough to be useful in it, and you turn what you learned into something others can reuse. | AdvancedYou can judge which new ideas are worth the team's time and which are not, and you make room for the people around you to learn too. | AdvancedYou can judge which new ideas are worth the team's time and which are not, and you make room for the people around you to learn too. | ExpertYou can set what the organization invests its learning time in, and the material and practice you create outlive your involvement. | |
| Communication4 | |||||
| BasicYou can explain your work so your team can act on it, and play a request back in your own words before you act on it. | ProficientYou can explain a complex topic to people with very different backgrounds, adjusting the detail to the audience without talking down to them. | AdvancedYou can bring disagreeing groups to agreement on the facts and the next steps, and help colleagues frame a difficult or sensitive message. | AdvancedYou can bring disagreeing groups to agreement on the facts and the next steps, and help colleagues frame a difficult or sensitive message. | ExpertYou can set how the organization communicates by creating the forums and norms that teams use to share information. | |
| BasicYou can work well with people in other roles, share context and credit, and take criticism of your work without defending territory. | ProficientYou can build working relationships beyond your own team and get things done through people who do not report to you. | AdvancedYou can align teams with competing priorities on a common goal, surfacing the conflict early instead of letting it harden into resentment. | AdvancedYou can align teams with competing priorities on a common goal, surfacing the conflict early instead of letting it harden into resentment. | ExpertYou can remove the barriers that stop teams working together by putting in place routines and forums they use across the organization. | |
| BasicYou can document your own work well enough for a colleague to follow it unaided, such as a how-to guide or a handover, and keep it current as things change. | ProficientYou can write for a defined audience, whether a proposal, a policy, a report, or a decision record, and make the reasoning as clear as the conclusion. | AdvancedYou can own the documents behind a large piece of work, coordinating contributions so that people who were not involved can carry it on. | AdvancedYou can own the documents behind a large piece of work, coordinating contributions so that people who were not involved can carry it on. | ExpertYou can set the writing standard the organization works to, and documents you wrote are still in use long after you have moved on. | |
| NoviceYou can keep your manager and immediate team informed of your progress, and you raise an issue before someone else discovers it. | BasicYou can identify who is affected by your work and keep them updated at a level of detail and a frequency that suits them. | ProficientYou can win support for a proposal, reset expectations when the plan changes, and turn down a request with a reason the other side accepts. | AdvancedYou can hold senior and external relationships, negotiate between competing demands, and deliver unwelcome news without losing trust. | ExpertYou can represent the organization in its most important relationships and set how it engages with everyone who depends on it. | |
| Leadership3 | |||||
| NoviceYou can act on direction well, seek feedback on how you work, and be open about what you need help with. | BasicYou can spot a problem and propose a way forward unprompted, and you take a small leading role such as running a working group. | ProficientYou can lead one piece of work shared by several people, on your own team and beyond, and make calls that they act on. | AdvancedYou can lead across team boundaries, build the credibility that makes people follow you by choice, and create room for others to lead. | ExpertYou can set direction for the whole organization, make hard calls under real uncertainty, and carry the decisions nobody else wants to own. | |
| NoviceYou can share what you have just learned with your peers and help a newer colleague find their way around. | BasicYou can help someone new settle into your team's work, answer their questions patiently, and give feedback specific enough to act on. | ProficientYou can mentor someone over months, tell them the uncomfortable thing they need to hear, and adapt how you teach to how they learn. | AdvancedYou can develop other mentors, coach people through career decisions rather than tasks, and lift the capability of a whole team. | ExpertYou can shape how the organization grows its people, and those you developed are themselves named by others as strong in their field. | |
| NoviceYou can explain why the work you were given matters and who it is for. | BasicYou can connect your team's work to its goals and question a task that does not appear to serve them. | ProficientYou can look a year ahead in your area, name what will matter by then, and turn that into work people can pick up now. | AdvancedYou can set direction for an area, choose deliberately what not to do, and defend that choice when it is challenged. | ExpertYou can shape the organization's strategy, and the bets you argued for are visible in where it ended up. | |
Use this ladder with your own team
For managers and HR teams: create a free account, then add software engineering from Departments → Add from template in one click: all 39 skills, with the mastery expected at each of your 5 career levels.