Senior Software Engineer job description

Software engineering — Senior
Leads delivery of a system and raises the bar for the team.

RESPONSIBILITIES
- Design systems spanning several components and teams where the requirements are still contested.
- Set the programming conventions your team follows, including for changes of high technical complexity.
- Apply modern development standards to complex multi-team work and lead others in adopting them.
- Review high-risk changes such as data migrations, security-relevant code and cross-team interfaces.
- Lead diagnosis of intermittent and production-only failures that have already defeated others.
- Plan and land a structural change across several components, keeping it reversible and visible to the teams affected.

REQUIREMENTS
- Experience at the Mid Software Engineer level (level 2 of 5) or equivalent

REQUIRED SKILLS
Software Development
- Programming and Build — You can set the programming conventions your team follows, including for changes of high technical complexity.
- Modern Development Standards — You 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.
- Code Review — You 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.
- Debugging and Diagnosis — You 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.
- Refactoring — You 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.
- Version Control — You 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.
- API Design — You 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.

Testing and Quality
- Test Design — You 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.
- Test Automation — You 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.
- Performance Optimization — You can trace a missed performance budget to its cause.
- Accessibility Testing — You 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.

Systems and Design
- Systems Design — You 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.
- Systems Integration — You 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.
- Architectural Decisions — You 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.
- Schema and Query Design — You 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.
- Prototyping and Spikes — You 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.
- User Focus — You can choose between ways of building a feature using usage data and user feedback, stating the user impact of each.

Operations and SRE
- Continuous Delivery — You can design the delivery approach for a product, covering how changes are gated, released progressively and rolled back.
- Observability and Monitoring — You 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.
- Production Incident Response — You 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.
- Availability and Capacity — You 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.
- Infrastructure as Code — You 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.

Security and Data
- Application Security — You 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.
- Secure Data Handling — You 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.
- Dependency Management — You 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.

Delivery
- Project Management — You 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.
- Planning & Estimation — You can estimate a whole project including its risks and unknowns, split it into stages, and defend the estimate when it is challenged.
- Ownership & Accountability — You can hold accountability for outcomes delivered mostly by other people, taking the blame when it fails and passing on the credit when it works.
- Quality Focus — You 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.

Craft
- Problem Solving — You can make the call on a problem outside your expertise and explain its cost, time and risk.
- Domain Expertise — You can advise the team on your area and apply new developments in the field where they pay off.
- Continuous Learning — You 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.

Communication
- Communication — You can bring disagreeing groups to agreement on the facts and the next steps, and help colleagues frame a difficult or sensitive message.
- Collaboration — You can align teams with competing priorities on a common goal, surfacing the conflict early instead of letting it harden into resentment.
- Writing & Documentation — You can own the documents behind a large piece of work, coordinating contributions so that people who were not involved can carry it on.
- Stakeholder Management — You can win support for a proposal, reset expectations when the plan changes, and turn down a request with a reason the other side accepts.

Leadership
- Leadership — You can lead one piece of work shared by several people, on your own team and beyond, and make calls that they act on.
- Mentoring — You can mentor someone over months, tell them the uncomfortable thing they need to hear, and adapt how you teach to how they learn.
- Strategic Thinking — You can look a year ahead in your area, name what will matter by then, and turn that into work people can pick up now.