Senior QA Engineer

About the Role

We're looking for a Senior QA Engineer to own the health of every release.

That sentence is the whole job, and we mean it literally: you own the release gate. If your suite is green, we ship. If it’s red, we don't. Nobody overrides a red gate by asserting that it's probably fine; they either fix the product or fix the test with you.

That authority only works if the gate is trustworthy, which is where the engineering is. A gate that flakes gets ignored within a week. A gate that takes ninety minutes gets bypassed. A gate that passes vacuously - a suite that asserts nothing, a check that skipped, a probe that read an empty response as healthy - is worse than no gate at all, because it looks like coverage. Your real product is a signal the whole company believes without checking.

You will build that signal with AI as your primary lever, not as a garnish. Generating, maintaining, and repairing tests is exactly the kind of work modern models are good at, and a single engineer using them well can hold coverage that used to need a team. We expect you to industrialise that: agents that turn a merged spec into API and end-to-end coverage, that triage a failure to a probable cause before a human opens it, and that keep selectors and fixtures current instead of letting them rot. We're a small, distributed, AI-first team - this is a high-autonomy, high-consequence role, not a ticket queue.

Our surface today: a Python/Django + DRF backend on Postgres and Redis, a TypeScript/Next.js customer-facing app, GitLab CI, Terraform, Docker, and a set of third-party carrier, airline, and tracking integrations that misbehave in ways no unit test will ever predict.

What You'll Own

• The release gate: One command, one verdict, on every release. You define what must be true before code reaches customers, you make that decision automated and repeatable rather than a judgement call, and you keep the runtime short enough that nobody wants to skip it.
• API test automation: Broad, fast, deterministic coverage of our Django/DRF surface — contracts, auth and permission boundaries, pagination, error shapes, idempotency, and the integration seams where a carrier or airline API changes its mind without telling us.
• End-to-end front-end automation: Real browser coverage of the journeys that earn revenue and the ones that generate support tickets, in a modern framework (we'd reach for Playwright), stable enough to run on every merge rather than nightly.
• AI-driven test generation and maintenance: Build the pipeline that turns a spec into a first-pass suite, keeps suites current as the product moves, and drafts the fix when a selector or fixture goes stale. Maintenance cost is the thing that kills automation programmes; automating maintenance is the point.
• Failure triage that arrives with an answer: When the gate goes red, the team should get the failing assertion, the diff or deploy most likely responsible, and a first hypothesis — not a link to a log. Increasingly that triage is an agent's first pass and your verification.
• Flake as a defect class: Track flake rate as a real metric with a real budget. Quarantine, root-cause, and fix — never silence. A test that was muted to unblock a release is a decision that has to expire.
• Environments and test data: Reproducible environments and seeded, realistic fixtures, so a failure means something and a pass isn't luck.
• Non-functional coverage where it matters: Performance regressions on the