Quality Assurance Engineer

We are looking for a detail-oriented Quality Assurance (QA) Engineer to join a team that works in a spec-driven way. This is not a role that starts once the code is finished. You will be part of the delivery process from the first draft of a specification through to release, making sure that what we agreed, what we built, and what we verified all still line up.

In practice, that means helping shape Functional Specification Documents (FSD) and writing Gherkin scenarios with acceptance criteria that leave little room for interpretation. You will verify what developers deliver across backend, frontend, and integration layers, review their code against our engineering standards, check the security and performance testing they have run, and then lead the full QA cycle before anything ships.

Our delivery process is spec-driven and gated. Each stage has to be verified before the next one starts, and QA is the verifying party at every gate:

• Planning: requirements are captured in an FSD and written as Gherkin scenarios with clear, testable acceptance criteria.
• Development: developers build against the specification and write unit tests covering the agreed behaviour.
• Specification verification: QA confirms that the implementation genuinely satisfies the FSD and acceptance criteria across backend, frontend, and integration layers.
• Standards review: QA compares the delivered code against our internal engineering standards and practices.
• Engineering process verification: developers run SAST, DAST, and performance testing. QA reviews the results and the coverage before sign-off.
• QA testing cycle: QA runs functional, end-to-end, smoke, fuzzy, A/B, and non-functional testing before release.

• Join requirement and FSD discussions from the planning stage, and push back on ambiguity before it reaches development.
• Write and review Gherkin scenarios (Given / When / Then) that turn business requirements into behaviour anyone can test.
• Define clear, measurable acceptance criteria for each feature, including edge cases, negative paths, and boundary conditions.
• Spot delivery risks early through test planning, analysis, and realistic estimation of effort and resources.
• Produce and maintain test plans, test cases, and traceability between requirements, scenarios, and coverage.

• Confirm that delivered backend, frontend, and integration code actually satisfies the FSD and its acceptance criteria, not just that it runs without errors.
• Review unit tests written by developers for coverage, correctness, and alignment with the agreed acceptance criteria.
• Validate API contracts, data flows, and system interactions using tools such as Postman or JMeter.
• Confirm behaviour across service boundaries, including event-driven and asynchronous workflows.
• Raise gaps between specification and implementation as soon as you find them, and see them through to resolution with the developer responsible.

• Compare delivered code against our internal standard practices, covering structure, naming, error handling, logging, and maintainability.
• Review findings from static and dynamic analysis tooling (SAST and DAST) such as Snyk, CodeQL, or Semgrep, and make sure they are addressed rather than quietly deferred.
• Check the performance testing developers have run, including whether the scenarios is realistic, the thresholds are sensible, and the results have been read correctly.
• Hold back sign-off when the evidence is incomplete, and write down clearly what is needed to close the gate.

• Design and run functional and end-to-end test suites for web and mobile applications.
• Run smoke tests on each build to confirm it is worth taking into a deeper test cycle.
• Carry out fuzz and negative testing to surface unhandled inputs, malformed payloads, and unexpected system states.
• Run regression and integration testing to confirm that new work has not broken anything that already worked.
• Handle non-functional testing (performance, load, stress, and security) and report results against agreed thresholds.
• Work across both manual and automated testing, and grow automation coverage where it will keep paying off.

• Track, document, and manage bugs, risks, and issues so that anyone can reproduce and understand them.
• Classify defects by severity and impact, and give stakeholders an honest read on release risk.
• Work with developers and cross-functional teams to trace issues back to root cause rather than patching the symptom.
• Coordinate with internal stakeholders and vendors so that testing stays aligned with business requirements and delivery runs smoothly.
• Bring ideas for improving our testing processes, tooling, and methods.
• Maintain and extend automated test suites inside CI/CD pipelines so quality gates run continuously instead of by hand.
• Explore AI-augmented and agentic testing workflows where they…