# How to Remove the Dev-to-QA Handoff Without Hiring QA

> Remove the dev-to-QA handoff without hiring QA: verify each change on its pull request, give every check a named owner, and measure what changes.

Source: https://qa.tech/blog/dev-qa-handoff · Published: 2026-11-16

---
The dev-to-QA handoff goes away when verification moves to the pull request. An independent check runs the flows a change can reach in a deployed preview and posts its verdict on the PR, with the evidence one click away, before a reviewer opens it. The author acts on the verdict, and no one new is hired.

## Why the dev-to-QA handoff slows releases, and how to remove it without hiring QA

Say you run an engineering team that never had a QA function, or let it go, or is about to lose its one tester with no plan to replace them. If you have a QA team and intend to keep it, the companion piece is [getting your QA team on board with AI testing](https://qa.tech/blog/qa-team-ai-testing-buy-in), and if the question in your company sits with product, it's how product managers [ship without a QA team](https://qa.tech/blog/no-qa-team-no-problem-how-pms-can-ensure-product-stability).

Teams that have testers know [the handoff pattern and why it persists](https://qa.tech/blog/the-qa-process-killing-your-sprint-velocity-how-fix-it). Here the other side of the handoff is empty, or about to be.

It tends to arrive in one of a few ways. The single tester resigns, and the list of what to check before a release turns out to have lived in their head. Or the QA team is cut in a reorganisation and testing is declared to have moved to developers, and no one measures how well they do it. Or a dozen engineers who never had a tester now ship far more code than a year ago, because agents write a good share of it.

Take the second case. The rule used to be simple: nothing ships until QA signs off. When the QA team is cut, that rule doesn't get replaced. It lapses. A few months on, no one can say what share of changes got any check beyond the author's own, and whether a change gets tested at all is down to whoever wrote it.

So the handoff went, and the check went with it. The old stage isn't coming back, because developers don't want to test and the business won't wait for QA. A manager in that spot wants the check without the wait.

### What the handoff costs

[DORA's guide to test automation](https://dora.dev/capabilities/test-automation/) describes the cost in two parts. The first is waiting: when testing is its own phase, developers "have to wait a long time to get feedback on their changes" once the work is marked dev complete. The second is what the wait does to ownership. The same page notes that under schedule pressure, teams can start to treat quality as "somebody else's problem".

The newer data is about where the delay has moved. [Faros](https://www.faros.ai/blog/ai-speed-trap-takeaways) reports that time in QA got worse than any other major efficiency and flow metric in its latest dataset, 12 months of telemetry from 22,000 developers across 4,000 teams. It's one vendor's telemetry, so treat it as a signal. Faros's own reading, in the same post, is that as AI-generated code arrives and gets less review, "QA inherits the verification burden, where it is often slower and more expensive."

None of this is an argument against testers. [DORA's guide](https://dora.dev/capabilities/test-automation/) says so itself: "Testers and QA teams continue to have an important role in this way of working," and it describes tester as "a role, not necessarily a full-time job". This article is about keeping that role alive on a team where nobody holds it as a job.

### When the check quietly disappears

Some teams remove the handoff by removing the check, on purpose. Developers verify with their own AI tools and ship when it looks right, and the team treats the bugs that reach users as the price of speed. For a small product with forgiving users and cheap rollbacks, that can be a reasonable call.

It gets less reasonable as the blast radius of a bad release grows. [The Pragmatic Engineer](https://newsletter.pragmaticengineer.com/p/qa-across-tech)'s 2024 survey of QA practices across tech included one engineer's account of quality declining after their company discontinued dedicated QA roles, which the author said "seems normal after such a change". That's one account, from before coding agents. It's also what you'd expect when a check goes and nothing takes its place.

## Why "developers just test their own work" isn't enough on its own

The default replacement for a QA stage is a sentence in a team meeting: from now on, developers test their own work. Half of that is right. [DORA's research](https://dora.dev/capabilities/test-automation/) found that performance improves "when developers are primarily responsible for creating and maintaining suites of automated tests" and can fix failing tests easily. Developers should own the automated tests.

The other half is where it breaks. Owning the tests is a different thing from being the only person who ever checked your change. An author tests the path they built, with the data they had in mind, in the order they imagined a user would click. Ask people to test what they built themselves and they have blind spots, however careful they are. It's one of four failure modes we go through in the section on [who actually does QA on your team](https://qa.tech/blog/the-ultimate-beginners-guide-to-qa-testing).

There's a motivation problem too. Engineers mostly don't enjoy testing. Tell a developer to click around a preview before every merge and you've made an engineer into a manual tester, doing a job they'll rush.

Coding agents sharpen both problems. When an agent wrote the change, the author may never have run it. And an agent asked to check its own output is marking its own homework, with the same blind spots a person has and for the same reason.

So the position here is narrow. Developers don't test by hand. An independent verifier checks every change on the pull request. Developers act on the verdict.

## The operating model: verification at the pull request

Here's the sequence for a single change.

1. Product writes what should be true for the user in the ticket, as [acceptance criteria an agentic tester can check](https://qa.tech/blog/acceptance-criteria-agentic-testers), and the author repeats it in the PR description. This replaces the handoff note.
2. The PR opens and a preview of that branch deploys. Plenty of teams already have [preview environments](https://qa.tech/blog/preview-environments) and use them only for a reviewer to click around.
3. A verification step that's independent of the author runs against the preview. It exercises the flows the change can reach, checks the stated criteria, and runs a short fixed list of critical paths.
4. The result lands on the PR as a verdict with evidence: what was tried, what happened, screenshots, logs. The verdict needs three outcomes. Pass, fail, and unable to verify for when the check never reached the change.
5. The author fixes failures while the change is still in their head, and the reviewer reads the code with the evidence attached.
6. For user-facing changes, product opens the preview and answers one question: is this what we meant?

It's a form of [shift-left testing](https://qa.tech/use-cases/shift-left-testing): the check moves to the earliest point where the change exists in a running app. The step can be an agent, a scripted suite, or both. The handoff goes because of where the step runs (on the PR, before human review) and who runs it (something other than the author).

A scripted end-to-end suite runs fast, repeats exactly and carries no licence bill. If yours is reliable, it's already your critical-path floor, so leave it running. A fixed suite can't cover the thing this PR just added, which is the part a tester used to pick up by hand. The shape that works pairs the two: a short list of critical paths checked on every change, and dynamic testing aimed at whatever this PR touched. Sorting an existing suite into those halves is the plan in [how to replace your regression suite](https://qa.tech/blog/replace-regression-suite).

### Who owns what, before and after

| Activity | Before (a handoff, or a gate that's gone) | After (verification at the PR) |
|---|---|---|
| Saying what "working" means | In the tester's head, or in a ticket nobody reread | Product writes acceptance criteria in the ticket; the author restates them in the PR description |
| Checking the change works in a running app | The QA queue, the author clicking around, or no one | The verification step, on the PR's preview, before human review |
| Checking nothing critical broke | A regression pass before release | A small critical-path suite on every PR, with one named engineer as its owner |
| Acting on a failure | A ticket back to the developer, days later | The author, in the same PR, while it's still open |
| Reviewing the code | The reviewer reads the diff and sometimes pulls the branch to try it | The reviewer reads the diff with the evidence attached |
| Judging whether it's what we meant | Whoever tested last | Product, on the preview, for user-facing changes |
| Keeping rules, test accounts and test data current | The tester's memory | The engineering manager at first, then a rotating owner |
| Deciding to merge | QA sign-off, or no one in particular | Author and reviewer, behind a required check where your Git host supports one |

The row that gets skipped is the one about rules and test data. When a tester leaves, what goes with them is knowledge: which account has the awkward permissions, which flow breaks every time billing changes, what "done" means for the reports page. Somebody has to write that down. In the first month, that somebody is you.

Some teams go a step past the last row. Once a verification verdict and CI are both green, they let certain low-risk changes merge without a second human approval. Whether that suits you depends on how complex the product is and how regulated.

## Running the verification step with an agent

An agent in this seat has limits a manager should hear before the pitch. It reports on behaviour and has no view on code quality, so a bug appears only when a test reproduces it. Intent that was never written down is invisible to it, so a vague PR gets a vaguer check. And its picks vary: review the same change twice and the selection may not match exactly, which written rules narrow.

QA.tech, an [AI testing platform](https://qa.tech/), takes steps 3 and 4 of that sequence. On each testable pull request its agents start from what the PR description and the linked Jira or Linear ticket say should be true, read the diff for the flows it touches, and exercise those flows on the preview. Test cases you already have are reused first, and new ones are written only where nothing covers the change. The riskier the change, the more gets run, so a small diff in a sensitive place can get the deeper pass. The PR then shows pass, fail or unable to verify, one click from the run with the screenshots, the logs and a trace of each step, plus a recording where one was captured.

Criteria come from the PR description and the linked ticket, and no format is required. For Jira that means Jira Cloud and the ticket's description; custom fields and comments aren't read. You can't pin particular test cases into a review. The fixed floor is a smoke test plan of the few flows you choose, run on every pull request in parallel with the review, through the Test Run Action with blocking on GitHub or the Start Run API from GitLab CI or Azure Pipelines. Anyone on the team can write a test case in plain language.

The merge gate is GitHub only: the review shows up there as a check, and branch protection can require it. GitLab and Azure DevOps get the review as a comment on the request, and a blocking test plan job is what can stop a pipeline. Without a preview per PR, the review moves to after the merge and runs against staging. There it can no longer block the merge, and when staging carries several people's merges, a failure can't always be traced to one of them.

When you compare the best AI testing agents for high-velocity engineering teams and there are no testers to double-check them, two questions come before speed. Does every verdict come with evidence a developer can check for themselves? And does the agent say so when it couldn't confirm a change? The point of [PR testing against the preview deployment](https://qa.tech/product/pr-testing) is that a manager can let the team merge at the pace it already writes code, because something other than the author opened the app first. You can try it on one application with the [free trial](https://qa.tech/pricing), and there's a page on [AI testing for CTOs and engineering leaders](https://qa.tech/solutions/ctos) if you need to make the case upward.

## What a manager sets up in the first two weeks

Week one is about getting a verdict onto every PR without blocking anything.

- [ ] Confirm every PR gets a deployed preview. If it doesn't, decide now: fix that first, or verify after merge on staging and accept that there's no merge gate.
- [ ] Write down the critical paths. Sign-up, login, payment, and the handful of flows that would ruin your week. Turn each into a test that runs on every PR.
- [ ] Create test accounts, one per role, with data that's safe to break.
- [ ] Add a PR template with four fields: what changed for the user, why, what to test, what's out of scope.
- [ ] Connect the verification step to one repository and let it report without blocking.

Week two is for reading the output and tightening.

- [ ] Read every verdict yourself for a week. Sort each failure: real bug, wrong test, environment problem, unable to verify.
- [ ] Turn what you learn into written rules: which accounts to use, what to skip, what always needs a second look.
- [ ] Tell product what they now sign off, and what they can stop checking.
- [ ] Name an owner for the critical-path suite and one for triage.
- [ ] Make the check required on your main branch once the team trusts its failures.

The order matters. Block merges on day one, before anyone has seen what a false alarm looks like, and the team learns to resent the check. A week of non-blocking verdicts shows you which rules are missing.

Not sure the handoff is your real constraint? The [five-question QA process audit](https://qa.tech/blog/how-to-audit-your-qa-process) is a faster way to find out than changing the process.

## What to measure

| Metric | What it tells you | Watch for |
|---|---|---|
| Time from PR opened to verdict | Whether the check is faster than the queue it replaced | Verdicts that arrive after the reviewer has already approved |
| Share of merged PRs with a verdict before merge | How much of what ships was checked by something other than its author | The share staying flat while PR volume climbs |
| Unable-to-verify rate | How often the check couldn't reach the change | Whether the cause is missing test data or an unreachable preview |
| Bugs found after merge, traced to a PR | What got past the check | The same flow appearing twice, which means a missing critical path |

Rows two to four are the verification half of the scorecard in [DORA metrics in the AI era](https://qa.tech/blog/dora-metrics-ai-era), which says where each number comes from, and they move with the practices in [how to increase developer velocity](https://qa.tech/blog/how-to-increase-developer-velocity). Cost isn't in this table because it needs a model of its own, the one in [the full AI cost of shipping a feature](https://qa.tech/blog/ai-cost-per-feature).

## Where this model doesn't fit

Regulated teams that must run and sign off a full regression pass keep doing that. PR verification sits in front of the pass and doesn't stand in for it. Products with hardware in the loop keep manual testing for the physical part.

Subjective calls stay human everywhere: whether the design feels right, whether the copy sounds like you. So does exploratory poking at something new. On a team without testers these land on product and on whoever built the feature.

And if you have a good tester, this isn't a plan for losing them. The queue comes off their desk, and the rules and the critical paths become theirs to own.

## FAQ

### Why does the dev-to-QA handoff slow releases?

Because finished work waits. A change marked done sits until someone else has time to check it, and when a bug comes back, the author has moved on and has to reload the context. [DORA's test automation guide](https://dora.dev/capabilities/test-automation/) adds a second cost: when testing is a separate stage, teams under schedule pressure can start treating quality as somebody else's problem. More code per developer makes the wait longer.

### Should developers test their own code?

Developers should write and maintain the automated tests for what they build, and [DORA's research](https://dora.dev/capabilities/test-automation/) ties that to better delivery performance. It stops working when the author is the only check on their own change, because people test the path they had in mind when they built it. Pair developer-owned tests with a check that's independent of the author.

### Why do we need dedicated QA if developers test code?

You need the testing role. Whether you need it as a job title depends on the product. Dedicated QA earns its place where judgement matters most: exploratory testing of something new, regulated releases that need a named sign-off, products with hardware, and deciding where the team's quality bar sits. If that describes you and you have testers, the useful question is how their work changes, and [getting a QA team on board with AI testing](https://qa.tech/blog/qa-team-ai-testing-buy-in) starts by putting what they own in writing.

### How do I scale test coverage without growing the QA team?

Stop tying coverage to the size of a suite someone maintains by hand. Keep a short list of critical paths that run on every change, and have each pull request tested for what it changed. Test cases written for a PR that turn out to be worth keeping can join the suite afterwards, so coverage grows where the product is changing.

### Who tests when there are no QA engineers on the team?

Testing doesn't become anyone's second job. An independent check verifies each change on its pull request, and the author fixes what it finds. One named engineer owns the short list of critical paths that can block a merge, and product signs off user-facing changes on the preview. The part teams forget is what a tester carried in their head: the test accounts, the rules, what "done" means. Someone has to own that in writing.

### What are the alternatives to hiring an in-house QA team?

A [managed QA service](https://qa.tech/blog/best-qa-automation-services-for-b2b-saas-companies) takes the whole problem off your team: someone else owns the suite and answers for coverage, and you keep a handoff, now to an outside party. Developers with a scripted end-to-end suite get speed and determinism for the flows they thought to script. A product owner doing a final pass is good at judging intent and can't cover everything that didn't change this sprint. Verification on the pull request by an agent checks each change as it's made and needs someone to own its rules. The scripted suite and PR verification work well as a pair.
