Senior Software Engineer job description

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

REQUIRED SKILLS
Software Development
- Programming and Build — You can deliver changes of high technical complexity across several components, and you set the programming conventions your team follows. You review others for design as well as correctness, and you are who people ask when a build or a risky change goes wrong.
- 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.
- Defect Management — You can manage defects and their dependencies across teams, decide what is escalated and when, and drive contingency plans. You contribute to the standards your organisation uses for defect handling.
- Test Strategy — You can develop and implement a test approach with a team, contribute to the wider organisational strategy, and put in place the measures that show whether the approach is actually working.
- Performance Testing — You can plan and run load, soak and stress work for a service, identify the limiting resource from evidence, and turn the finding into a specific change. You know when a measurement is not trustworthy.
- 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.

Operations and SRE
- Continuous Delivery — You can design the delivery approach for a product, including how changes are gated, released progressively and rolled back, and you shorten the time from commit to production. You remove a manual approval by replacing it with a check, not by dropping it.
- Observability and Monitoring — You can decide what a service needs to expose for its behaviour 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 a service you know, judge the impact, choose between mitigating and fixing, and keep the people who need to know informed. You write the follow-up so the actions are specific and owned.
- 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 authorisation 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, minimised, 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 run a multi-person project end to end: you set the scope, track the dependencies between the people involved, and re-plan when reality moves.
- Planning & Estimation — You can estimate a whole project including its risks and unknowns, split it into milestones, and hold the estimate up under challenge.
- Ownership & Accountability — You can hold accountability for outcomes delivered mostly by other people, absorbing the blame when it fails and passing on the credit when it works.
- Quality Focus — You can design the quality practice for complex work owned by several teams, and you anticipate the failure modes that only appear once systems interact.

Craft
- Problem Solving — You can solve problems in domains where you are not the expert, and your solutions hold up on cost, performance, and maintainability at once.
- Domain Expertise — You can be the person the team consults on your area, and you follow where the field is moving and apply it where it pays 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 a shared understanding, and colleagues come to you for help framing 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.
- Technical Writing — You can own the documentation of a large project, coordinating contributions so the work can be maintained by people who never built it.
- Stakeholder Management — You can win support for a proposal, reset expectations when the plan changes, and refuse a request with a reason the other side accepts.

Leadership
- Leadership — You can take charge of work with no clear owner, motivate people who do not report to you, and make calls others are willing to follow.
- 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.