Key takeaways
- In Agile, quality is a whole-team responsibility. Testers bring testing skills to the team; they don't own quality alone.
- Testers add value at every Scrum event: refining stories, planning, daily work, review and retrospective, not only at the end of the sprint.
- The Agile testing quadrants help a team check it isn't missing whole kinds of testing, like performance or exploration.
Where this picks up
You've seen how testing fits the software development life cycle in general. Agile changes the rhythm: short iterations, small increments, constant feedback. Testers need to work differently to keep up.
Scrum in two minutes
The Scrum Guide (2020 edition) defines:
- Three accountabilities: Product Owner, Scrum Master and Developers.
- Five events: the Sprint, Sprint Planning, the Daily Scrum, Sprint Review and Sprint Retrospective.
- Three artifacts: Product Backlog, Sprint Backlog and the Increment, with the Definition of Done as the quality standard for the Increment.
Notice what's missing: there's no "tester" role. In Scrum, Developers means everyone who creates the increment, including people whose speciality is testing. Testing is part of the team's work, not a hand-off to someone outside it.
What testers do in each event
| Event | What a tester contributes |
|---|---|
| Backlog refinement | Asks questions, finds gaps, helps write testable acceptance criteria and examples |
| Sprint Planning | Points out testing effort and risks; makes sure testing is in the estimate |
| During the sprint | Tests stories as soon as pieces work; pairs with developers; automates; explores |
| Daily Scrum | Raises blockers: an environment down, a story not testable yet |
| Sprint Review | Shares what was learned about quality; observes how stakeholders react |
| Retrospective | Brings evidence: escaped bugs, flaky tests, testing bottlenecks |
The Agile testing quadrants
Brian Marick proposed the quadrants, and Lisa Crispin and Janet Gregory made them widely known in their book Agile Testing (2009). They sort testing by two questions: does it support the team while building, or critique the product once something exists? Is it business-facing or technology-facing?
| Supports the team | Critiques the product | |
|---|---|---|
| Business-facing | Q2: examples, story tests, functional tests, prototypes | Q3: exploratory testing, usability, user acceptance, demos |
| Technology-facing | Q1: unit and component tests | Q4: performance, security, reliability ("-ility" testing) |
The quadrants aren't an order or a pyramid. They're a checklist: if your team does lots of Q1 and Q2 but no Q4, nobody is checking performance or security.
Definition of Done
The Definition of Done is the team's shared standard for "finished". Testing belongs in it. For example:
- Acceptance criteria are met and checked.
- New code has unit tests; key flows have automated tests.
- No open critical or major bugs for the story.
- Exploratory testing done for risky stories.
- Accessibility checked for UI changes.
A story that isn't tested isn't done, and doesn't count in the increment.
The mini-waterfall trap
The most common Agile testing problem: developers code for nine days, then hand everything to testers on day ten. It's waterfall, compressed into two weeks.
How to avoid it:
- Make stories small, so each one can be built and tested in a couple of days.
- Limit work in progress. Finish and test a story before starting the next.
- Test early pieces: an API before the UI, a single screen before the whole flow.
- Share testing. Developers test too. Testers coach and focus on the risky parts.
- Automate regression continuously, so it doesn't pile up at the end of the sprint.
A Scrum team finished most stories on the last two days of each sprint. The single tester worked late, bugs spilled into the next sprint and the team's velocity looked good while quality didn't.
In a retrospective, the tester showed a simple chart: when each story arrived for testing. Almost all arrived in the final 48 hours.
The team agreed to a work-in-progress limit of three stories, to split stories into smaller slices and to hold three amigos sessions. Two sprints later, stories reached testing throughout the sprint, and spill-over bugs dropped sharply.
Lesson: the problem wasn't too little testing capacity. It was the flow of work. Showing the data made it a team problem, not a tester problem.
Do
Bring testing questions into refinement: "What should happen if the payment times out?" Each answer becomes an acceptance criterion and a test.
Don't
Wait for stories to be "ready for QA". By then, the cheapest moment to find problems has passed.
Check yourself
Your team's tests are almost all unit tests and automated functional checks. Using the Agile testing quadrants, what might be missing?
Show answer
Mostly Q3 (exploratory testing, usability, acceptance with real users) and Q4 (performance, security, reliability). The team checks that it built things right, but not how the product behaves for real users or under real conditions. Suggest adding exploratory sessions for risky stories and planning at least basic performance and security checks.
