DeviQA team

DeviQA team

Posted: 19.11.2026

19 min read

Reported delivery outcomes across 48 product teams with different QA entry points.

Executive summary

Most engineering teams say QA should be involved earlier. Few have measured what changes when it is. This report compares 48 product teams, grouped by the stage at which QA first joins feature work, across six months of delivery.

Teams that involve QA at backlog refinement, compared with teams that hand QA a finished feature:

  • cut rework cycles per feature from 2.8 to 1.6 (−43%);
  • raise first-pass acceptance from 41% to 69%;
  • halve combined QA + developer rework time: 18.4 → 9.3 hours per feature;
  • reduce features with mid-build requirement changes from 46% to 18%;
  • catch 43% of defects before implementation is complete (vs. 6%) and only 16% in regression or after release (vs. 36%);
  • cut post-release hotfixes from 19% to 8% of releases and raise on-time releases from 57% to 79%;
  • invest about 1 extra hour of QA time before testing for roughly 6 fewer hours of rework after it.

Discovery-stage involvement improves every metric further, but by smaller increments — and 46% of developers see no benefit from early QA on simple, low-risk changes. The conclusion is not "earlier is always better." It is that refinement is the point of best return, and discovery pays off for complex, integration-heavy, high-risk work.

Methodology and reporting framework

The study covers 48 product teams from external companies (not DeviQA engagements), 12 per group. Teams were assigned to groups by their actual working process — the stage at which QA engineers first participate in feature work — rather than by self-description. From each team, two people responded: one QA engineer and one developer or Tech Lead, 96 respondents in total.

Responses were collected 15–30 October 2026 and cover features and releases from the preceding six months. Feature-level metrics (requirement changes, rework, defect detection stage) are shares of features delivered in that period. Release-level metrics are shares of releases. Time metrics are per-feature averages. Sections 6 and 7 apply only to the 24 teams in the refinement and discovery groups.

Group
When QA joins
Teams

After completion

QA receives finished functionality for testing

12

After implementation starts

QA joins once development is already underway

12

At refinement

QA participates in preparing requirements and acceptance criteria

12

At discovery

QA takes part in requirements, design, and risk discussions before refinement

12

Introduction

"Shift left" has been part of the QA vocabulary for more than a decade, and almost every engineering organization claims to practice it. Ask a team when QA actually joins feature work, and the answer is usually some version of "when there is something to test."

That gap between the stated process and the real one is where most rework lives. A feature is specified, estimated, built, and handed to QA. QA finds that an edge case was never discussed, that two acceptance criteria contradict each other, or that a user role was left out of the design. The feature goes back. The developer, now on something else, switches context to fix it. QA retests. The release absorbs the delay, or the test scope gets cut to protect the date.

Teams know this loop. What they rarely know is what it costs — and whether moving QA earlier changes the numbers or just moves the same work to a different column in the sprint. This report answers that with comparable data across four groups that differ in one systematic way: when QA first touches a feature.

Two findings frame everything below. The differences between groups are not marginal — they are large on every metric. And the biggest step change happens at refinement, not at discovery.

Requirements: where rework is born

Most rework does not start with a coding mistake. It starts with a requirement that was incomplete, ambiguous, or contradictory when the developer opened the ticket. By the time QA sees the result, the cost of fixing it includes the original implementation, the fix, and at least one extra round of testing.

Metric (share of features)
After completion
After impl. starts
Refinement
Discovery

QA regularly finds requirement gaps before implementation (share of QA engineers)

n/a

n/a

67%

83%

Requirements changed significantly after implementation started

46%

34%

18%

12%

Features reworked due to inaccurate requirements

31%

24%

12%

8%

Expected behavior clarified only during testing

38%

29%

15%

10%

In late-QA teams, 46% of features had their requirements changed significantly after development began — nearly half. In refinement teams, 18%; in discovery teams, 12%. The direct cost of that movement is the second row: 31% of features reworked because of inaccurate requirements in late-QA teams versus 12% at refinement — a 61% reduction. Not because the code was wrong, but because the specification was.

The third row is the quieter cost. In late-QA teams, QA had to stop and ask what the correct behavior was supposed to be on 38% of features, because the ticket did not say. In refinement teams, 15%. Each of these is a conversation that should have happened before the first line of code — and in early-QA teams, it did: 67% of QA engineers at refinement and 83% at discovery say they regularly find requirement gaps before implementation starts.

The step between the second and third groups is the largest on every row. Joining after implementation starts helps — the developer is still available and some questions get answered before the code hardens — but the requirement is already being built. Joining at refinement means the question is asked while changing the answer is still free. Put concretely: a late-QA team shipping 100 features sees roughly 46 with mid-build requirement changes, 31 reworked for specification reasons, and 38 needing clarification in testing. The same team at refinement: 18, 12, and 15.

Bar chart showing that involving QA earlier in feature development sharply reduces requirement-related problems.

Rework cycles and first-pass acceptance

Once a feature reaches QA, the question is how many times it goes back. Each test → fix → retest cycle costs QA time, developer time, and a context switch for both.

Metric
After completion
After impl. starts
Refinement
Discovery

Avg. test → fix → retest cycles per feature

2.8

2.3

1.6

1.3

Features passing first QA check without significant rework

41%

52%

69%

76%

Avg. fix + retest time per feature

13.8 h

11.2 h

7.5 h

6.4 h

Avg. combined QA + dev rework time per feature

18.4 h

14.7 h

9.3 h

7.8 h

A late-QA team averages 2.8 cycles per feature — nearly three passes before approval. A refinement team averages 1.6: one pass, and a second about half the time. That is a 43% reduction in rework cycles. The same effect shows in first-pass acceptance: 41% of features clear QA first time in late-QA teams, 69% in refinement teams, 76% at discovery. For more than two-thirds of a refinement team's features, the first QA pass is also the last substantive one.

The hours follow. Fix-and-retest time per feature falls from 13.8 to 7.5 hours; combined QA and developer rework time from 18.4 to 9.3 hours — cut almost exactly in half. For a team delivering 20 features a month, that gap is roughly 180 hours a month, more than one full-time engineer's capacity spent redoing work instead of delivering it.

Discovery improves the numbers further, but the increments shrink: 0.3 fewer cycles, 7 more points of first-pass acceptance, 1.1 fewer hours of fix-and-retest time. The pattern repeats in every section — the refinement step is where the bulk of the gain lives.

Two-chart comparison showing that bringing QA in earlier in feature development cuts rework cycles by 43% and rework hours by half.

Where defects get caught

The cost of a defect depends less on what it is than on when it is found. Caught while the requirement is being discussed, it costs a sentence. Caught in regression, it costs a fix, a retest, and often a slipped release. Caught after release, it costs a hotfix and whatever users experienced in between.

Share of all defects found
After completion
After impl. starts
Refinement
Discovery

Before implementation is complete

6%*

21%

43%

52%

During first functional testing

58%

51%

41%

37%

Only in regression or after release

36%

28%

16%

11%

*For late-QA teams, "before implementation is complete" means defects caught by unit tests, developers, or other team members — QA has not yet seen the feature.

The distribution shifts as a block. Late-QA teams are weighted toward the end of the cycle: 6 / 58 / 36. Discovery teams are weighted toward the start: 52 / 37 / 11 — more than half of all defects are identified before the implementation is finished. Refinement sits close to the discovery profile at 43 / 41 / 16.

The share found in functional testing falls as QA moves earlier — not because QA finds less, but because a growing portion of defects has already been caught upstream and never reaches testing as a defect. The expensive end moves most: 36% of defects found only in regression or after release in late-QA teams versus 16% at refinement, a 56% reduction.

The planning implication is direct. A late-QA team that budgets regression time from functional-test results is systematically underestimating what regression will find — more than a third of defects are still ahead of it. A refinement team working from the same results has already seen most of what there is to see. This is the mechanism behind the report's central claim: early QA does not primarily make testing faster. It changes where defects live.

Bar chart showing that the earlier QA gets involved, the more defects are caught before implementation is complete.

Impact on releases

Share of releases (six months)
After completion
After impl. starts
Refinement
Discovery

Required a hotfix after release

19%

14%

8%

5%

Delivered on the planned date

57%

66%

79%

85%

Test scope cut due to time pressure

32%

25%

14%

10%

Delayed by late-found issues

27%

20%

11%

7%

In late-QA teams, nearly one release in five needs a hotfix and one in three ships with reduced test scope. The two outcomes feed each other: late-found issues (27% of releases delayed) force a choice between slipping the date and cutting regression, and cutting regression is what lets defects through to production.

Refinement teams deliver 79% of releases on the planned date versus 57%, cut scope on 14% of releases versus 32%, and need hotfixes on 8% versus 19%. Discovery teams improve each figure by another 4–6 points. Every release metric improves monotonically with earlier involvement, and the ordering of the four groups never changes across any row — a consistency that would be unlikely if the groups differed on something other than QA timing.

Line chart showing release outcomes steadily improve the earlier QA joins feature work.

Time invested before testing vs. time spent after

The obvious objection to early QA is that it costs QA hours before there is anything to test. This section measures that cost against the return.

Avg. per feature
After completion
After impl. starts
Refinement
Discovery

QA time before the feature enters formal testing

0.2 h

0.6 h

1.2 h

1.7 h

Rework + retesting time after implementation

13.8 h

11.2 h

7.5 h

6.4 h

Total time from implementation complete to QA approval

21.4 h

17.6 h

11.8 h

9.9 h

From post-completion to refinement, QA adds 1.0 hour of pre-testing involvement per feature, and the team saves 6.3 hours of rework — a trade of roughly 1:6. From refinement to discovery, the additional 0.5 hour saves 1.1 hours, about 1:2. The return is highest at refinement and diminishes after it.

Elapsed effort tells the same story from the release manager's side: time from "code complete" to QA approval falls from 21.4 to 11.8 hours at refinement and 9.9 hours at discovery. A feature reaches a releasable state in 45–54% less effort after the code is written.

One caveat matters here more than elsewhere: all hours are self-reported. The 1:6 ratio is the right order of magnitude to plan around, but teams should validate it against their own tracked data before using it in a business case.

Bar chart showing return on early QA investment: each extra hour spent on QA before testing saves about six hours of later rework.

What QA catches before implementation (24 early-QA teams)

Issue regularly found by QA at refinement/discovery
Share of QA engineers

Missed edge cases

79%

Unclear or contradictory acceptance criteria

75%

Unaccounted user roles

67%

Integration risks

63%

Mismatch between requirements and design

54%

Testability problems

50%

Unconsidered impact on existing functionality

46%

Security or permission risks

29%

Multiple answers allowed; totals exceed 100%.

The top three — edge cases (79%), acceptance criteria (75%), user roles (67%) — are specification defects, not code defects. They are exactly the categories that become mid-build requirement changes (Section 1) and regression-stage defects (Section 3) when nobody asks about them before coding. Integration risks (63%) and requirement–design mismatches (54%) are the next tier, and both are expensive to discover late because they typically span more than one team or component.

Two items at the bottom are informative in a different way. Testability problems (50%) are something only QA is positioned to raise at refinement — a feature designed without hooks for automation costs the team every regression cycle afterward. Security and permission risks (29%) are found least often, which points to a gap in what early QA review currently covers rather than an absence of such risks.

Bar chart listing issues QA regularly catches before coding starts.

What developers say (24 early-QA teams)

Statement
Developers agreeing

The whole delivery cycle became more predictable

79%

QA questions helped clarify or change the implementation before coding

75%

QA helped surface integration risks earlier

71%

QA participation reduced clarifications during development

67%

Planning and refinement took slightly longer

58%

For simple, low-risk changes, early QA gave no noticeable benefit

46%

Developers confirm both the cost and the return. 58% say planning and refinement take slightly longer; 79% say the overall delivery cycle became more predictable. Three-quarters say QA questions changed or clarified the implementation before coding started, and two-thirds say they fielded fewer clarification requests during development — the developer-side mirror of the 38% → 15% drop in Section 1.

The last row is the report's counterweight. 46% of developers see no noticeable benefit from early QA for simple, low-risk changes. This is not a failure of the practice; it is its boundary. Early QA earns its time on complex functionality, integrations, critical business logic, and high-risk changes. Applied to every copy update and config change, it becomes the kind of process overhead that gets abandoned under sprint pressure.

Bar chart showing developers see early QA involvement as making the delivery cycle more predictable and reducing mid-development clarifications.

Limitations

Group sizes of 12 teams show direction and magnitude, not statistical significance. Teams may differ in requirements quality, staffing, engineering experience, automation coverage, feature complexity, leadership, and release practices. All time figures are self-reported estimates, not extracted from tracking systems. The study describes association, not causation — teams that involve QA early may differ in other ways (maturity, product complexity, leadership), although the consistent ordering of all four groups across every metric makes QA timing the most parsimonious explanation.

Key findings

  • Refinement is the point of best return. Every metric improves monotonically with earlier QA involvement, but the largest single step is from "after implementation starts" to "at refinement."
  • Early QA prevents wrong implementations; it does not just start testing sooner. Requirement-driven rework drops from 31% to 12% of features.
  • Defect discovery shifts upstream as a block. Defects found only in regression or after release fall from 36% to 16% at refinement and 11% at discovery.
  • One hour before testing ≈ six hours saved after it (refinement vs. post-completion); the ratio falls to ≈1:2 for the additional move to discovery.
  • Releases become predictable. On-time delivery rises from 57% to 79%; hotfixes fall from 19% to 8%; scope cuts fall from 32% to 14%.
  • Developers pay in planning time and get it back in rework. 58% report longer refinement; 79% report a more predictable cycle.
  • Discovery is for complex work, not every change. 46% of developers see no benefit for simple, low-risk changes.

Recommendations

  • Make refinement the default entry point for QA. QA reviews requirements and acceptance criteria before estimation, with three expected outputs: an edge-case list, a role and permission matrix, and a testability check. These map directly to the three most common gaps in Section 6.
  • Reserve discovery involvement for high-risk work. Trigger it for integrations, changes to critical business logic, features touching several existing flows, and anything with security or permission implications — the categories where the extra 0.5 hour still pays.
  • Define the threshold for skipping it. Copy updates, configuration changes, and isolated UI tweaks do not need QA at refinement. Write the rule down; an implicit threshold does not survive sprint pressure.
  • Measure the trade with tracked data. Log QA hours before formal testing and rework hours after it, per feature, for one quarter. Compare the ratio against the 1:6 benchmark here before building a business case on it.
  • Track two leading indicators. First-pass acceptance rate and the share of defects found in regression or post-release move first; cycle time and hotfix rate follow within a release or two.

Conclusion

Across the participating teams, earlier QA involvement was associated with lower reported rework, higher first-pass acceptance, and more favorable release outcomes.

The refinement group showed substantial differences from teams involving QA during or after implementation. Discovery teams reported stronger results again, with smaller additional differences.

The study does not establish that QA timing alone produced these outcomes. It provides a reason to evaluate refinement as an earlier entry point and to measure the full effort trade using a team’s own delivery data.

The practical question is whether clearer decisions before implementation are accompanied by less downstream rework, and which kinds of changes justify the additional review.