Mid Software Engineer job description

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

RESPONSIBILITIES
- 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.
- Design the data structures for a feature with the right keys, constraints and indexes, and write migrations that change a live schema without downtime.
- Build a pipeline that takes a change from commit to production through automated checks.
- Take a medium-complexity feature from specification to production on your own, choosing appropriate structures and tools.
- Apply the team standards without prompting and help a colleague adopt them.
- Review changes in areas you do not own and catch design problems, not only style.

REQUIREMENTS
- Experience at the Junior Software Engineer level (level 1 of 5) or equivalent

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, releasing each step on its own, and explain when a refactor is not worth doing.
- 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 and write its specification before implementing it.

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.
- Performance Optimization — You can profile the code you changed to find its slowest step.
- 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 behavior 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 learned, including the part you failed to answer. You stop at the time box instead of polishing code that will be discarded.
- User Focus — You can trace a ticket back to the user need behind it and check your change against that need before you hand it over.

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 add logs and metrics to the code you write and set up a straightforward alert under direction.
- Production Incident Response — You 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.
- 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 authorization 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 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.
- Planning & Estimation — You can estimate your own work with reasonable accuracy and keep 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 accountable for it, including the parts nobody enjoys.
- Quality Focus — You 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.

Craft
- Problem Solving — You can break a large, ambiguous problem into pieces and weigh the options for each against the evidence.
- Domain Expertise — You can work confidently with the tools and methods 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.
- Writing & Documentation — You 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.
- Stakeholder Management — You can identify who is affected by your work and keep them updated at a level of detail and a frequency that suits them.

Leadership
- Leadership — You can spot a problem and propose a way forward unprompted, and you take a small leading role such as running a working group.
- Mentoring — You can help someone new settle into 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.