
The Role of QA in Agile: What QA Owns in Every Sprint

Key Takeaways
QA in Agile works best at the start of the sprint: QA turns stories into testable acceptance criteria in refinement, and the whole team owns quality.
- In backlog refinement, QA asks how each story could fail and rewrites vague criteria as concrete examples. Those criteria set the ceiling on testing quality.
- All Developers in the Scrum team are accountable for quality through the Definition of Done. A QA specialist still designs tests and works as one of the Developers.
- QA has work in every Scrum event, from adding test effort to estimates in planning to bringing escaped-defect and flaky-test data to the retrospective.
- A smoke subset runs in CI on every merge and the full regression suite runs nightly. Flaky tests are quarantined and fixed within a sprint.
- Tagging each test with its story ID lets the team update affected tests in the same sprint when a requirement changes.
- Defect leakage shows whether earlier QA works. In one project Muhammad Haris describes, about 25 of about 180 defects reached production, roughly 14%.
Bring QA into backlog refinement and require testable acceptance criteria before a story enters sprint planning.
The role of QA in Agile is to shape quality before and during development, starting at backlog refinement. An Agile QA engineer turns user stories into testable acceptance criteria, plans test work inside each sprint and keeps automated checks running on every merge. The whole Scrum team owns quality, and QA brings the testing expertise. If your QA engineers first see a story when the build is ready, they have missed the refinement conversation, where testable criteria get written.
What is Agile testing?
Agile testing is testing done continuously inside each sprint, alongside development, so every user story is verified while it is being built. Three habits set it apart:
- Developers and testers work together daily, so problems surface while the code is still fresh.
- Testing runs in small, frequent cycles that match the sprint cadence.
- Test scope moves with the requirements, because each story is tested as it is built.
How QA in Agile differs from waterfall QA
In waterfall, testing is a phase that starts after the build and checks the product against a specification written months earlier. In Agile, testing runs inside every sprint, and a story counts as done only when it passes its acceptance criteria and the team's Definition of Done.
| Aspect | Waterfall QA | Agile QA |
|---|---|---|
| When testing starts | In a separate test phase after the build phase ends | In refinement, before code exists, then on each story as it is built |
| What tests check against | A specification fixed at the start of the project | Each story's acceptance criteria and the team's Definition of Done |
| Who owns quality | The test team, as a gate before release | All Developers in the Scrum team, with QA leading test design |
| Test documentation | A full test plan written up front | Acceptance criteria on each story and a short test charter per sprint |
| When a requirement changes late | The test plan and schedule are reworked | Affected tests are updated in the same sprint or the next one |
The second row changes the job most. When acceptance criteria are what every test checks against, the quality of those criteria sets the ceiling on the quality of the testing. That moves QA's most useful work to the moment the criteria get written.
A common objection is that Agile removes the need for dedicated QA. The 2020 Scrum Guide defines Developers as "the people in the Scrum Team that are committed to creating any aspect of a usable Increment each Sprint" and makes them accountable for "instilling quality by adhering to a Definition of Done." Someone still needs the skill to design tests, find the risk in a story and keep a regression suite trustworthy, and on teams that keep a QA specialist, that person works as one of the Developers.
What does QA do in each sprint ceremony?
QA has work in every Scrum event, and the most valuable part happens before anyone writes code. The table maps the Agile QA process across one sprint.
Sprint activity | What QA does | What it produces |
|---|---|---|
Backlog refinement | Asks how each story could fail, rewrites vague criteria as concrete examples, flags stories that will be hard to test | Acceptance criteria with examples, including negative cases |
Sprint planning | Adds test and automation effort to estimates, checks that test environments and test data exist for the sprint goal | Test tasks on the board and a short test charter |
Daily scrum | Reports stories blocked in test and environment or data problems | Early warning on stories at risk of missing the Definition of Done |
During development | Agrees unit and API test scope with developers, reviews pull requests for testability, writes automated checks in parallel, explores each story as it lands | Automated tests merged with the story and defects fixed in the same sprint |
Sprint review | Demos tested behavior and records stakeholder feedback as new scenarios | Backlog items for missed scenarios |
Sprint retrospective | Brings data on escaped defects, flaky tests and stories that bounced back from test | One or two process changes for the next sprint |
Refinement is where embedded QA pays off. In a post on Arbisoft's blog, Muhammad Haris describes a Scrum project where a user story asked for an "enhancement to the search functionality" without saying which filters changed, how invalid input should behave or what performance was expected. A QA engineer in refinement would ask what a misspelled query should return and what response time is acceptable. The answers become criteria that developers and testers read the same way. His write-up on testing challenges from requirements to production covers more cases like it.
What QA adds to the Definition of Done
The Definition of Done turns the team's quality accountability into a checklist every story must pass. QA is well placed to propose items like these:
- Every acceptance criterion has a passing test, automated where the behavior is stable.
- The negative and edge cases agreed in refinement are covered.
- New automated checks run in the CI pipeline and pass on the merge.
- The smoke suite is green after the merge.
- An exploratory session on the changed flow is done, with notes on the story.
- No open critical defects remain against the story.
Agile testing quadrants and who runs each one
The agile testing quadrants check whether a test strategy covers more than functional checks. Brian Marick created the original agile testing matrix, and Lisa Crispin and Janet Gregory later adapted it. It sorts tests on two axes, business-facing or technology-facing, and guiding development or critiquing the product.
| Quadrant | What it covers | Example tests | Who usually leads |
|---|---|---|---|
| Q1, technology-facing, guides development | Automated tests on a small area of code that give fast feedback | Unit and component tests | Developers, with QA reviewing scope |
| Q2, business-facing, guides development | Examples that turn into specifications and story tests | Acceptance tests from refinement examples, often written as Cucumber scenarios in Gherkin | QA with the product owner |
| Q3, business-facing, critiques the product | Human-centric testing of whether features deliver value to the customer | Exploratory testing of finished stories | QA |
| Q4, technology-facing, critiques the product | Non-functional checks such as performance, load and security, usually run with tools | Performance testing | QA with specialists |
Crispin notes that the numbering implies no order, and that most projects start with Q2 because that is where examples turn into specifications and tests that drive coding. For QA, Q2 is the quadrant to own, because the refinement examples become the acceptance tests. Moving that work earlier is the core of shift-left testing in QA, and Q3 time goes furthest with the techniques in how exploratory testing makes QA more effective.
Why do requirements change?
Requirements change because the market, the users, the available technology and the business all move while a product is being built. Common triggers include:
- A competitor launches a feature, and the product owner reorders the backlog to respond.
- Feedback in a sprint review shows users struggling with a flow, so the next stories change.
- A new library or platform release makes a simpler implementation possible.
- The business shifts its focus, for example toward a new customer segment, and some planned features drop out.
A fixed test plan treats each of these as a disruption. Agile testing plans for them, and the affected stories and tests are adjusted in the current or next sprint.
How does Agile testing handle changing requirements?
Agile testing treats each requirement change as new input to the current test scope and updates the affected tests in the same sprint. That only works when each test case and automated script is tagged with the ID of the story it checks.
Consider an illustrative case. Halfway through a sprint, stakeholder feedback leads to a redesign of a checkout step already in development. The QA engineer works through four steps:
- Confirm the new acceptance criteria with the product owner, and agree with the team whether the redesign fits this sprint or moves to the backlog.
- Search the suite for the story ID to list the affected test cases and automated scripts.
- Update or retire those tests, and add new ones for the changed criteria.
- Run an exploratory session on the redesigned flow plus the regression suite before the story meets the Definition of Done.
A change agreed verbally in a standup never reaches the story, and the tests keep checking the old behavior. A short three amigos conversation between the product owner, a developer and the tester settles an unclear change, and the agreed answer goes into the story before any code or test changes.
What testers do when requirements change
When a requirement changes, the tester connects the team with business stakeholders and turns the change into concrete test work:
- Joining refinement from the start, so a changed requirement reaches the tester at the same time it reaches the developer.
- Testing each story as soon as it is built, so a change touches a small, known set of tests.
- Keeping a short test charter per sprint in place of one long plan, updated the same day a story changes.
- Updating the automated tests in the same sprint as the story that changed them, so failing or outdated scripts never pile up.
What happens to test cases when a story changes or is dropped mid-sprint
The tester updates the test cases that cover the changed behavior and retires the ones tied to dropped functionality. Tests that still check valid behavior stay in the regression suite. The story ID tag on every test makes each group easy to find.
Principles of Agile testing for handling change
Six principles keep the cost of a requirement change low:
- Collaborate with stakeholders on each change. Testers, developers and stakeholders agree on what changed and why as soon as it is proposed, so tests check the agreed behavior and not an old assumption.
- Test in increments. Each increment is tested as it is built, so a change affects only the tests for the stories it touches.
- Test from the user's perspective. A story that passes its tests but confuses users still needs work.
- Automate regression checks. The team can accept a change without waiting days for a manual regression run.
- Design tests for maintenance. Modular test cases with shared steps, data-driven tests that keep data separate from logic, and one test per acceptance criterion make the affected tests quick to find and update.
- Adjust tests from feedback. Sprint reviews and demos show where the product and its tests have drifted from business goals, so testers add missing scenarios and drop checks for behavior nobody needs.
Automation and CI in the Agile QA process
Short sprints leave no room for days of manual regression. Automation carries the repeat checks, and QA time goes to new and changed stories. A common shape is the test pyramid: many unit tests that run in seconds, fewer API tests that check how services work together, and a small number of UI tests for the main user journeys.
A fast smoke subset runs in the CI pipeline on every merge, and the full regression suite runs nightly. Flaky tests go into quarantine as soon as they fail at random and get fixed within a sprint, moved down to the API or unit level where possible. A team that learns to ignore red builds has lost its regression safety net.
Tool choice matters less than upkeep. Typical stacks pair Selenium or Cypress for browser tests with Appium for mobile, JUnit for unit tests, Cucumber for Gherkin scenarios written from acceptance criteria, and Jenkins or GitLab CI for pipelines. Whatever the stack, sprint planning needs time for maintaining the automated tests each story changes.
Which QA metrics and reports work in Agile?
Defect leakage is a useful QA metric in Agile because it measures the share of defects that reach production. The formula is defect leakage (%) = production defects / total defects × 100.
Haris reports a project that logged about 180 defects, about 25 of them in production, a leakage of approximately 14%. He found that high leakage consistently correlated with poor requirement clarity and late QA involvement. Tracked per sprint, leakage shows whether moving QA earlier is working.
A few process signals show where a sprint leaks:
- stories reopened after testing, which point to weak acceptance criteria
- the number of flaky tests and how long they stay in quarantine
- time from merge to test feedback in CI
- defects caught in refinement or review compared with defects found after the merge
Test execution counts need care. Haris saw projects where true coverage was low despite high execution numbers. A QA report in Agile works best as one page for the sprint review: what was tested, what wasn't and why, open risks and the leakage trend.
Common challenges for QA in Agile, and the fixes
- Testing squeezed into the last days of the sprint. When development takes most of the sprint, test cases shrink to happy paths and more defects escape. Testing each story as soon as it merges and limiting work in progress spread test work across the sprint.
- QA left out of refinement. QA that joins only at sprint planning, or hears about work when a build is ready, reacts late to scope changes. Adding QA attendance at refinement to the team's working agreement fixes the cause.
- Obsolete tests that keep passing. Tests for behavior that has changed give false confidence. Pruning retired tests by story ID in each retrospective keeps the suite honest.
- Quality treated as QA's job alone. When developers hand stories over and move on, QA becomes the bottleneck. Developers owning Q1 tests and the whole team signing off the Definition of Done spread the load.
Frequently asked questions
How many QA engineers does an Agile team need?
There is no standard ratio. The need depends mostly on how much regression is automated and how risky the domain is. A team with a mature automated suite and developers who write their own unit tests needs less QA time per story than a payments team with heavy manual regression. If stories regularly wait in the test column, the team needs more QA capacity.
Should a mid-sprint requirement change go into the current sprint?
It depends on the size of the change. The product owner and the team weigh its impact on the sprint goal and the remaining capacity. Small clarifications usually go into the current sprint, and large changes such as a feature redesign usually go to the backlog for the next sprint planning.
Can Agile testing work without test automation?
Yes, for small products with few features. As the product grows, manual regression takes longer every sprint and crowds out testing of new stories. Teams at that point should automate stable, high-risk paths first, such as login, payments and core workflows, and keep exploratory testing manual.
How much documentation does Agile testing need?
Enough to show what is tested and why, kept light. Most teams keep acceptance criteria on each story, a short test charter per sprint and a documented regression scope listing which features the automated suite covers. That record shows new testers and reviewers the coverage without a long upfront test plan.
What skills should an Agile QA engineer have?
Test design comes first, followed by the ability to read code and API contracts and write automated tests. Domain knowledge of the product matters as much, because it shapes the questions QA asks in refinement. The best Agile QA engineers also stay curious about new tools and adapt quickly when requirements change.
Where the role of QA in Agile starts
The role of QA in Agile pays off most at the start of the sprint. If you change one thing, bring QA into backlog refinement and make testable acceptance criteria a condition for a story entering sprint planning. Automation and metrics then have something solid to check against. If your roadmap is growing faster than you can hire senior QA engineers, talk to Arbisoft's team about Agile QA and software testing services.
...Loading Related Blogs









