Quality Assurance Engineer

About the Role

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.

How We Work

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.

What You Will Be Doing

1. Specification and test design

•     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.

2. Verification against the specification

•     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.

3. Engineering standards and process verification

•     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 are 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.

4. The QA testing cycle

•     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.

5. Defect management and collaboration

•     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.

6. Continuous improvement

•     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 measurably cut effort or widen coverage.

What We Are Looking For

Education and experience

•     Bachelor's degree in Computer Science, Information Technology, or a related field.

•     2 years minimum professional experience in software quality assurance engineering and testing.

•     Experience working inside a structured or specification-driven delivery process.

Technical skills

•     Working knowledge of code enough to read, write, and debug test scripts and to review application code during verification.

•     Be able to use Git and configure MCP server/client to add more insight into your testing.

•     A solid grasp of testing methodologies: functional, regression, integration, smoke, and end-to-end.

•     Hands-on experience with automated testing frameworks such as Playwright, Cucumber, Selenium, Appium, Cypress, TestNG, or similar.

•     Experience writing and reviewing unit tests, and working with developers on unit-test coverage.

•     Confidence with API testing tools such as Postman or JMeter.

•     Experience with non-functional testing: performance, load, stress, and security.

•     Familiarity with static and dynamic code analysis tools for finding vulnerabilities and code-quality issues.

•     Familiarity with CI/CD pipelines and with wiring automated tests into them.

Process and documentation

•     Able to write and review Functional Specification Documents, and to turn requirements into Gherkin scenarios and acceptance criteria.

•     Clear, precise writing. Your defect reports and verification results need to be reproducible and hard to misread.

•     Comfortable holding a quality gate and explaining the reasoning behind a sign-off decision.

Nice to have

•     Exposure to AI-augmented or agentic testing tools and workflows.

•     Experience testing systems in regulated and enterprise environments such as audit, financial services, or government.

•     Familiarity with event-driven or asynchronous architectures.

•     Experience with fuzzy testing or property-based testing.

How you work

•     Strong attention to detail, with a habit of anticipating problems and finding the edge cases other people miss.

•     Proactive and adaptable, and comfortable in a fast-moving environment.

•     Willing to question specifications, implementations, and assumptions, including your own.