Software Testing

Intermediate path · lesson 13 of 19

IntermediateStrategy5 min readPublished November 12, 2026

Testing in Agile and Scrum

In Agile teams, testing isn't a phase or a department. It happens every day, inside the team. Here's how testers work in Scrum events, how the Agile testing quadrants guide what to test and how to avoid a mini-waterfall in every sprint.

On this page

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

EventWhat a tester contributes
Backlog refinementAsks questions, finds gaps, helps write testable acceptance criteria and examples
Sprint PlanningPoints out testing effort and risks; makes sure testing is in the estimate
During the sprintTests stories as soon as pieces work; pairs with developers; automates; explores
Daily ScrumRaises blockers: an environment down, a story not testable yet
Sprint ReviewShares what was learned about quality; observes how stakeholders react
RetrospectiveBrings 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 teamCritiques the product
Business-facingQ2: examples, story tests, functional tests, prototypesQ3: exploratory testing, usability, user acceptance, demos
Technology-facingQ1: unit and component testsQ4: 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:

  1. Make stories small, so each one can be built and tested in a couple of days.
  2. Limit work in progress. Finish and test a story before starting the next.
  3. Test early pieces: an API before the UI, a single screen before the whole flow.
  4. Share testing. Developers test too. Testers coach and focus on the risky parts.
  5. Automate regression continuously, so it doesn't pile up at the end of the sprint.
Real-world exampleFrom the last day to every day

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.