Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
Testing in Scrum

Testing in Scrum

A Guide for Software Quality Assurance in the Agile World
Make every sprint releasable without mistaking passing tests for trustworthy software.
by Tilo Linz 2014 240 pages
3.72
25 ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Make agile quality visible in every sprint, not just at release.

Short cycles need evidence. Scrum divides work into fixed-length Sprints, each intended to produce a product increment that could be released. That promise is hollow if testing waits for a separate final phase. Unit tests examine an isolated component, integration tests examine connected components, and system tests examine the product through user-facing interfaces and its operating environment. Each answers a different question, so none can stand in for the others.

Test the whole journey. In the book's eHome example, a successful test of a lamp's software state does not prove that a browser command reaches the physical lamp and receives confirmation. Linz argues for testing these levels in parallel during each Sprint, with frequent automated feedback where practical. The aim is to find defects while the relevant code and decisions are still fresh.

Analysis

What's striking is that testing is presented not as a final inspection, but as the information system that lets an adaptive process steer. This resembles feedback control: a system can correct its trajectory only when it can observe the difference between intended and actual behavior. Shorter development cycles without shorter feedback loops merely produce smaller batches of late surprises. The practical challenge is observability. A team needs results that arrive soon enough to change action, but an abundance of dashboards can become noise unless someone is accountable for interpreting failures.

Ship a thin, working slice each sprint, guided by a clear product vision.

Plan direction, not destiny. A product vision briefly describes what the product is for; an architecture vision sketches its major parts and interfaces. These guide a changing Product Backlog, the ordered collection of possible work. A story map groups related goals into a rough sequence, but is a guide rather than a promise of delivery dates. At Sprint Planning, the team selects a realistic subset for its Sprint Backlog.

Make completion testable. The Definition of Done is the team's explicit standard for declaring work complete. It should account for testing and other work needed to make the increment usable. Scrum favors finishing a small, working slice over building a broad layer that cannot yet function. Kanban, by contrast, has no required Sprints: it limits work in progress and aims to move independent tasks through a continuous flow.

Analysis

This planning model distinguishes uncertainty about the future from vagueness about the present. A flexible roadmap can respond to new evidence, while a clear completion standard prevents flexibility from becoming an excuse for unfinished work. That is a useful balance in any complex project. One caution: a story map can still be mistaken for a contractual schedule, especially when sales or leadership communicates it externally. Its uncertainty needs to be explained as clearly as its priorities.

Write the test before the code to expose assumptions while they are cheap.

Specify behavior first. Test First means writing and automating a test that fails before changing or adding the production code. The test describes what the new behavior should do; the programmer then changes the code until the test passes. In the eHome example, a team first defines how a new dimmer should start, report its brightness, and handle values at and beyond its allowed range. Those tests reveal design choices before they become embedded in implementation.

Let tests shape interfaces. Writing a test against a not-yet-built component forces the team to decide how another part of the system will use it. The book argues that this tends to produce clearer, more testable interfaces and quick feedback during coding. It also demands discipline and testing skill. Poorly chosen tests can pass while missing important behavior, so pairing, review, and training matter.

Analysis

Test First functions as a form of executable specification: it turns an expectation into something the machine can check repeatedly. That can reduce ambiguity between design and implementation, much as a working prototype can clarify a product brief. But executable does not mean self-explanatory. Tests can encode a mistaken assumption just as efficiently as a correct one. Pairing the test writer with someone focused on user needs helps counter the risk that a technically precise test quietly narrows the product to what is easiest to implement.

Do not confuse green coverage reports with proof that behavior is correct.

Coverage measures execution. A unit test checks one component independently, often replacing its dependencies with test doubles, which are simplified stand-ins for components the test object relies on. A test should set up the object, perform an action, check the result, and leave the object in a clean state. Testing methods separately is not always enough: when an object's behavior depends on its history, state-based testing checks how method calls behave from different starting states and what state follows.

A green report can mislead. In the book's Device example, tests can achieve 100 percent line coverage yet fail to test whether invalid status values are rejected or whether the lamp can switch correctly between on and off. Coverage shows which code ran, not whether the test asked the right question. Test cases should also cover valid and invalid inputs, boundaries, and important state transitions.

Analysis

The distinction between coverage and correctness is a general measurement lesson: a proxy can be useful without being the thing it represents. Line coverage is an indicator of exercised code, not a certificate of sound behavior. Treating it as a target can encourage teams to optimize the number rather than the risk being addressed. The stronger practice is to pair coverage information with requirements, state models, and test reviews, then investigate areas where a high score rests on shallow assertions.

Reduce dependencies before they turn integration testing into a combinatorial tax.

Interfaces create test work. Integration testing checks whether components communicate correctly, including their calls, data formats, timing, and responses. Dependencies may be direct, such as one class calling another, or indirect, such as two components sharing a database or file. The book contrasts a tree-shaped system, where dependencies grow roughly with the number of components, with a densely connected system, where possible links can grow much faster. These formulas are models, but the practical warning is clear: more connections mean more interactions to verify.

Build feedback into the workflow. Continuous Integration (CI) is an automated process that checks shared code as changes are added. A typical run builds the software, analyzes code, deploys it to a test environment, and runs automated tests, then reports results centrally. In an agile project, this catches mismatches soon after a change instead of at Sprint's end. Simple, explicit interfaces make both the architecture and its tests easier to understand.

Analysis

Architecture is often discussed as a question of elegance or future extensibility. Here it has a direct operational cost: every dependency adds a possible place for assumptions to disagree. This connects testability to modular design, where a small number of explicit boundaries make failures easier to isolate. The numerical growth comparison should not be treated as a universal forecast, since real dependencies differ in risk and frequency. Its value is diagnostic: when integration effort keeps rising, inspect the network of connections, not only the test team's speed.

Test through the user's world, not only through classes and APIs.

System tests cross boundaries. System testing checks whether the assembled product works through the interfaces customers use, in an environment that resembles their real one. For the eHome controller, that means following a command from a browser, through the controller and bus, to an actuator, then confirming that the action appears correctly to the user. This end-to-end path can reveal problems that isolated component tests cannot, including configuration and hardware mismatches.

Use the domain's language. Record-and-replay scripts can be brittle because they depend on screen layouts, labels, and interface details that change. Keyword-driven testing instead describes actions in terms of product behavior, such as switching a named lamp on, then checking its status. A Domain Specific Language is a small vocabulary designed for a particular application area. It takes effort to create, but can keep test intent stable even when the interface changes.

Analysis

The important shift is from asking whether a function works to asking whether a user can complete a meaningful task through the full system. That is close to service design, where the unit of value is the entire journey rather than a single internal handoff. Realistic test environments matter because software does not operate in a vacuum. Still, perfect imitation is often too costly. Teams need to choose representative configurations by customer importance and risk, rather than assuming one laboratory setup stands for every deployment.

Automate repeatable regression, reserve human attention for uncertain behavior.

Keep system feedback moving. Linz compares three approaches: test everything in a final Sprint, reserve time for testing at each Sprint's end, or automate system tests and run them continuously or nightly. The first two can delay feedback, expose the team to late defect-fixing work, and turn a Sprint into a mini-waterfall. Nonstop system testing brings repeatable checks into the CI process, though long tests may run nightly rather than on every code change.

Keep exploration human. Exploratory testing means investigating a feature while designing and performing tests, rather than following a complete script written in advance. Session-based testing adds a short goal, a time limit, and notes that make the work easier to review and reproduce. These methods help probe new or unfamiliar behavior. Automation is not a substitute for them: usability, unexpected workflows, and some visual results still require human judgment.

Analysis

This is a division of labor between machines and people, not a contest between them. Automation is valuable when the same question must be answered reliably after many changes. Human exploration is valuable when the question itself is still uncertain. The distinction resembles the difference between routine monitoring and open-ended inquiry. A risk remains if exploratory work is treated as informal and therefore disposable. Short written records preserve discoveries, while avoiding the burden of pretending every useful test can be scripted in advance.

Cross-functional teams still need serious testing expertise and independent judgment.

Shared ownership needs skill. In Scrum, developers, testers, and other specialists work within the same team, and quality is everyone's responsibility. This removes handoffs, but it does not make testing expertise unnecessary. Linz recommends that teams retain a qualified tester who can shape risk-based testing, advise on releases, and help other members develop their skills. The team also needs practical agreements on test automation, code review, coverage, and how defects are handled.

Proximity has a price. The AVID case study describes faster collaboration after testers and developers joined the same teams, but also notes that testers could begin to see problems primarily through a developer's perspective. Some were reluctant to report that a feature was not done. Cross-functional work succeeds when specialists contribute to shared goals without losing the ability to challenge assumptions or report unwelcome results.

Analysis

The book avoids a common organizational trap: interpreting shared responsibility as interchangeable competence. A team can own quality together while still relying on people with deep expertise in particular methods. The AVID experience also points to a social risk. Close collaboration builds context and trust, yet can weaken critical distance. Pairing and transparent results help, but teams should protect a norm in which raising a defect is treated as useful information, not disloyalty.

Keep compliance evidence lean, continuous, and traceable.

Agile still needs rules. Traditional quality systems can accumulate detailed documents that no longer match actual work. Linz argues for a concise description of how a team operates, supported by team-specific agreements and regular improvement through retrospectives. The goal is not to discard process control, but to keep documented rules useful and current. Quality management can shift from imposing procedures to helping teams find methods that work and satisfy organizational requirements.

Make evidence part of delivery. In regulated or safety-related work, traceability means being able to connect a requirement to its design, implementation, tests, and results. Done criteria can include required reviews, test coverage, or risk analysis. Because a team may decide late whether to release a build, creating compliance records after the fact is risky. A dependable process keeps the evidence with the work as it is produced.

Analysis

This is a useful correction to the false choice between bureaucracy and freedom. In safety-sensitive work, records are not merely administrative residue; they can help establish why a product is trusted and what changed when it was modified. The design challenge is to capture evidence as a natural output of development rather than as a parallel paperwork exercise. Lean documentation still needs governance: if each team interprets traceability differently, flexibility can produce gaps exactly where shared assurance is needed.

Fund the build-and-test system before promising faster delivery.

Infrastructure takes real time. The TestBench team moved from a four-hour build to a 15-minute build after redesigning its CI environment. Its nightly system suite eventually contained about 15,000 data-driven test steps and ran for roughly 10 hours, while a short exploratory session remained part of each Sprint. At GE Oil & Gas, the reported average interval to a first release or between releases fell from about a year under its older process to four months in agile projects. These are case reports, not guarantees.

Adoption is organizational work. Other cases describe challenges that tools alone could not solve: AVID needed clearer product ownership, zooplus embedded testers in teams, and Siemens had to transfer expertise while meeting medical regulations. Training, architecture, reliable test data, hardware, and management support all consume capacity. Teams should plan this foundation explicitly instead of counting only visible feature work.

Analysis

The cases make the book's promise concrete while also putting a boundary around it. Faster feedback and shorter release cycles are possible, but they are purchased through investment in automation, environments, skills, and coordination. A reported improvement from one organization cannot establish that Scrum alone caused the result; project type, product architecture, and implementation choices also matter. The more useful inference is operational: treat testing infrastructure as product-enabling work, then measure whether it reduces delay and rework in the local setting.

Analysis

The book's central argument is that Scrum does not make testing obsolete. It changes where testing belongs: from a downstream phase into the team's continuous work of building, integrating, and validating a product. The eHome controller provides a useful through-line. A tiny class that records whether a lamp is on may pass its unit tests, while the actual user journey can still fail at the browser, database, bus adapter, or physical device. That example captures the book's strongest insight: software quality is layered, and evidence at one layer cannot certify the next.

The practical architecture is deliberately broad. Planning gives the team direction without pretending the entire future is predictable. Test First makes behavior explicit before implementation. Unit and integration tests provide fast technical feedback, while system tests examine the assembled product in realistic conditions. Continuous Integration connects these layers to everyday work. Quality management and compliance extend the same logic to process rules and evidence.

The book's most valuable tension is between collective ownership and specialist expertise. A cross-functional team can reduce handoffs and speed diagnosis, but its members do not become equally skilled simply because roles blur. The case studies show that training, dedicated testing knowledge, tool investment, and organizational support remain essential. The same applies to automation: it can make regression checks frequent and reproducible, but it cannot eliminate exploratory judgment or guarantee useful coverage.

A contemporary reader should treat the case results as illustrations rather than promises. The organizations differ in product complexity, regulation, architecture, and maturity. Their shared lesson is more robust than any single metric: shorten the distance between a change and trustworthy feedback, then use that feedback to improve both the product and the way the team builds it.

Summary in 30 Seconds
Scrum teams need testing throughout development, from isolated components to integrated systems and real user workflows. Test-first practices clarify expected behavior early, while coverage reports alone cannot prove correctness. Continuous integration shortens the wait for feedback, and automation handles repeatable regression checks while human testers investigate uncertain behavior. Specialists, reliable infrastructure, and traceable compliance evidence remain essential. One case cut builds from four hours to 15 minutes.
Contains spoilers

Last updated:

Report Issue
Want to read the full book?

Glossary

Test First

Test before implementation

A development practice in which a team writes and automates a test for desired behavior before changing or creating the production code. The test initially fails because the behavior is absent. The code is then developed until the test passes. This makes expected behavior explicit early and supplies rapid feedback during implementation.

Continuous Integration

Automated checks on shared changes

A development process in which team members frequently add code to a shared, version-managed repository. Each change triggers an automated build and a sequence of checks, commonly including static analysis, unit tests, and integration tests. Results are made visible to the team so problems can be investigated near the time they are introduced.

test doubles

Stand-ins for dependencies

Replacement components used when testing a unit that depends on other components. A double can provide controlled responses, record interactions, imitate a simplified implementation, or serve only to satisfy a technical requirement. Stubs, spies, mocks, fakes, and dummies are different forms. They help isolate the test object and can make tests faster or possible before dependencies are ready.

state-based testing

Tests behavior across states

A testing approach for objects or systems whose behavior depends on their current state or recent history. A test identifies the initial state, the action and its inputs, the expected result, and the expected resulting state. State models help identify valid and invalid actions, transitions, and sequences that ordinary method-by-method tests may miss.

Definition of Done

Shared completion criteria

A team's agreed criteria for deciding that work is complete. The criteria can apply to tasks, features, or an entire product increment and may include testing, reviews, documentation, or other quality requirements. In Scrum, a clear Definition of Done helps ensure that a completed Sprint produces a usable, potentially releasable increment rather than work that still needs a separate finishing phase.

exploratory testing

Learn and test simultaneously

A manual testing approach in which the tester investigates a product while designing and performing tests. The tester begins with a goal, observes how the software behaves, and adapts the next steps to findings and uncertainties. It is useful for new or poorly specified features, but its value depends on the tester's skill and discipline.

session-based testing

Structured exploratory sessions

A way to organize exploratory testing around a defined objective, a limited time period, and a written session record. Notes can capture the test environment, areas explored, observations, defects, and unanswered questions. The structure helps teams review and reproduce exploratory work without requiring a complete scripted test plan in advance.

Domain Specific Language

Vocabulary for one application area

A deliberately limited language built around the concepts and actions of a particular product or field. In system testing, it can describe what a user expects the product to do without encoding the exact clicks or technical interface used to do it. Tests written in this vocabulary can remain useful when the product's interface or implementation changes.

Story map

Visual sequence of product goals

A planning view that groups related requirements into themes and gives the team and stakeholders a rough sense of the order in which goals may be addressed. It complements the Product Backlog by communicating direction across upcoming Sprints. It is an adaptive planning aid, not a binding commitment that a particular feature will arrive in a specified Sprint.

Download PDF

To save this Testing in Scrum summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.30 MB     Pages: 16

Download EPUB

To read this Testing in Scrum summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.35 MB     Pages: 20
Want to read the full book?
Follow
Listen
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
1M+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...