Senior QA Engineer (Automation & AI-Driven Testing)

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'll 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.

• 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 endpoints ops actually waits on, and accessibility checks in the front-end suite.
• Production verification and feedback: Smoke and synthetic checks after every release, and a closed loop from every escaped bug back into the suite — an incident that doesn't produce a test is an incident we've agreed to have twice.
• Quality as a shared practice: You're the owner of the gate, not the person who does everyone's testing. You raise the floor: review testability in specs, make the tools easy to write against, and coach engineers and agents alike into leaving coverage behind them.

Interested in remote work opportunities in QA & Testing? Discover QA & Testing Remote Jobs featuring exclusive positions from top companies that offer flexible work arrangements.

• First 30 days: You know how a change reaches production today, where our coverage actually is, and which failures we've been living with. You've replaced the riskiest manual pre-release check with an automated one and shipped it.
• First 60 days: A single gate command runs on every release with meaningful API and end-to-end coverage, in a runtime nobody argues with. Flake rate is measured and visible. AI-assisted generation is producing real tests, not demos.
• First 90 days: The gate is trusted enough that a red result stops a release without discussion. Escaped defects are trending down, each one has a test, and the coverage of new work arrives with the work instead of behind it.

• Someone who wants the accountability. "Own the health of every release" reads as an offer to you rather than a threat. You're comfortable being the person who says not yet, and you say it with evidence.
• An automation engineer first. You write real code and treat test code as production code — reviewed, refactored, and held to the same bar. Manual exploratory testing is a tool you use deliberately, not a job description.
• Suspicious by instinct. You ask what a green result actually proved. You notice the suite that passed because it skipped, the loop that iterated over an empty list, the assertion comparing two undefined values. You'd rather break your own check to prove it can fail than trust that it works.
• Genuinely AI-fluent. You already use LLMs and coding agents in your daily workflow and can talk specifically about what you've automated, what you've sped up, and where the tools burned you. You know that AI-generated tests are confidently wrong often enough to need a verification habit — and you have one. Enthusiasm without hands-on usage isn't what we're after.
• An excellent communicator. You write clearly for engineers and for the people waiting on a release, and a failure report from you tells the reader what to do next. Strong written communication is close behind hands-on skill in this role.
• A systems thinker about failure. You fix the class, not the instance. A bug's real cost to you is what it says about a missing category of coverage.
• Pragmatic about coverage. You know where the risk is and put the effort there. You're not chasing a percentage.
• Independent and async-native. Comfortable working across time zones without supervision, proactive about pulling context rather than waiting to be briefed, and reliable about the commitments you make.
• Low-ego and hands-on. You'll write the fixture, chase the flake, fix the CI job, and pair with the engineer whose test you're rewriting. Nothing is beneath the role.
• Balanced. You work hard during the day and value your personal time, stepping in outside hours only for genuine urgency.

• 5+ years in QA, SDET, or test-automation engineering, including ownership of an automated suite that a team genuinely depended on to release.
• Strong hands-on coding in Python and/or TypeScript — enough to read our application code, not just drive it from outside.
• Deep API testing experience against REST services, ideally Django/DRF: auth and permissions, contract and schema validation, and integration seams with unreliable third parties.

Browse our curated collection of remote jobs across all categories and industries, featuring positions from top companies worldwide.

• Real end-to-end browser automation experience — Playwright, Cypress, or equivalent — with a track record of keeping such a suite stable rather than merely writing one.
• CI/CD fluency: building and owning pipeline stages, parallelisation, artifacts and reporting, and gating a release on a result. GitLab CI experience is a plus; understanding what makes a gate trustworthy matters more.
• Demonstrated daily use of AI tools in your own workflow, with concrete examples — ideally including using them to generate or maintain tests.
• Comfort with containers and cloud environments (Docker, and infrastructure as code such as Terraform) to the degree that you can stand up and debug an environment yourself.
• Excellent written English.

Nice to have: performance and load testing, accessibility testing, contract testing, synthetic monitoring and observability tooling (we use Datadog), or a security-testing background.

If you meet most of this and are strong on automation depth and AI fluency, we'd rather see your application than not.

• A rare mandate: genuine, unambiguous authority over what ships, in a company that wants to be told no when no is the right answer.
• Build a quality function from a clean slate with modern tooling — you won't inherit a decade of brittle Selenium and a suite nobody trusts.
• Work in an environment where AI tooling is genuinely embraced, not merely tolerated — you'll get better at it fast, alongside people doing the same.
• Real ownership and short decision paths: no QA-versus-engineering politics, no committee, no theater. If you see a better way, you'll be the one who implements it.
• Your work is visible: freight moves in the physical world, and the difference between a good release and a bad one is a shipment that arrives or doesn't.
• A flexible, async-friendly, globally distributed team that respects your personal time and values results over hours clocked.

ClearJet is an equal opportunity employer. We hire on the strength of your work and your thinking, and we welcome applicants of every background, identity, and path into this profession.