Mid Software Engineer job description

Software engineering — Mid
Owns whole features end to end with little day-to-day direction.

REQUIRED SKILLS
Software Development
- Programming and Build — You 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.
- Modern Development Standards — You 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.
- Code Review — You 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.
- Debugging and Diagnosis — You 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.
- Refactoring — You can restructure a component with poor boundaries while it stays in production, sequencing the work so each step is releasable on its own. You also know when not to refactor and can say why.
- Version Control — You 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.
- API Design — You can design a small interface with sensible names, input validation and error responses, writing the specification down before implementing. You know that changing a published field can break callers.

Testing and Quality
- Test Design — You 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.
- Test Automation — You 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.
- 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 adapt a test approach to the risk of the work with some support, follow the agreed strategy and contribute to improving it. You can state plainly what the plan does not cover.
- Performance Testing — You can design a simple load test with a realistic workload and stated success criteria, run it against a representative environment, and report what you measured rather than what you expected.
- Accessibility Testing — You 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.

Systems and Design
- Systems Design — You 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.
- Systems Integration — You can build and test an integration against a documented interface under direction, handling the error responses that interface defines. You check the behaviour against a real instance of the other system rather than only a mock.
- Architectural Decisions — You 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.
- Schema and Query Design — You 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.
- Prototyping and Spikes — You can run a time-boxed spike on a defined unknown and write up what you learnt, including the part you failed to answer. You stop at the time box instead of polishing code that will be discarded.

Operations and SRE
- Continuous Delivery — You 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.
- Observability and Monitoring — You can instrument the code you write with useful logs and metrics and set up a straightforward alert under direction. You know which dashboard to open when someone reports that a service is behaving oddly.
- Production Incident Response — You can take a defined role in an incident, carry out an agreed mitigation and report status in plain terms. You know which changes are safe to make while a service is already degraded.
- Availability and Capacity — You 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.
- Infrastructure as Code — You 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.

Security and Data
- Application Security — You can apply the standard controls in your own code, validating input, encoding output and using the platform authentication and authorisation rather than inventing your own. You raise a security concern in review instead of assuming someone else saw it.
- Secure Data Handling — You 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.
- Dependency Management — You 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.

Delivery
- Project Management — You can break a small piece of work into tasks, sequence them, and run it to a date you agreed, escalating risks before they become slips.
- Planning & Estimation — You can estimate your own tasks with reasonable accuracy and deliver at a steady enough pace that other people can plan around you.
- Ownership & Accountability — You can pick up a problem that has no obvious owner and make yourself the accountable party for it, including the parts nobody enjoys.
- Quality Focus — You can define what good enough means for a project, put the checks in place to prove it, and hold back a release that misses the bar.

Craft
- Problem Solving — You can break a large, ambiguous problem into tractable pieces, weigh the options against evidence, and explain the tradeoff you chose.
- Domain Expertise — You can work confidently across the systems and tools your team uses daily, and you can explain how your work serves the team's goals.
- Continuous Learning — You can pick up an unfamiliar area fast enough to be useful in it, and you turn what you learned into something others can reuse.

Communication
- Communication — You can explain a complex topic to people with very different backgrounds, adjusting the detail to the audience without talking down to them.
- Collaboration — You can build working relationships beyond your own team and get things done through people who do not report to you.
- Technical Writing — You can write for a defined audience, whether a proposal, a runbook, or a decision record, and make the reasoning as clear as the conclusion.
- Stakeholder Management — You can identify who is affected by your work and keep them updated at a level of detail and a cadence that suits them.

Leadership
- Leadership — You can identify a problem and propose a way forward unprompted, and you take a small leading role such as running a working group.
- Mentoring — You can onboard someone onto your team's work, answer their questions patiently, and give feedback specific enough to act on.
- Strategic Thinking — You can connect your team's work to its goals and question a task that does not appear to serve them.