Sprint Execution and Quality Management (part 2: 6.4–6.6)
Open in the Padhaiko app6.4 Creating Shippable Functionality: Elaborating, developing, and verifying
Delivering a potentially shippable Increment at the end of every Sprint requires turning each User Story from a brief card into verified, production-ready software inside the same Sprint—never leaving half-tested code for a later "hardening phase." Agile teams achieve this through a tight, story-by-story micro-cycle of elaborating, developing, and verifying.
The Story-Level Creation Cycle (Elaborate -> Develop -> Verify)
- Elaborating (Just-in-Time Discovery): Right before or at Sprint start, the Three Amigos (Product Owner, Developer, and Tester/QA) clarify business rules, edge cases, data validations, and concrete Given-When-Then acceptance criteria so ambiguity is removed before coding begins.
- Developing (Incremental Vertical Construction): Developers build a thin vertical slice spanning UI, application logic, and database changes using clean design, peer code reviews (or pair programming), TDD, and frequent Continuous Integration (CI) commits to the shared trunk.
- Verifying (Continuous Quality Confirmation): Automated unit/integration tests run on every commit, QA performs exploratory edge-case testing, and the Product Owner confirms all Acceptance Criteria and the Definition of Done (DoD) are satisfied while the work is still fresh.
6.4.1 Vertical Slicing vs. Horizontal Mini-Waterfalls
| Aspect | Anti-Pattern ("Mini-Waterfall" Sprint) | Healthy Agile Flow (Vertical Story Cycle) |
|---|---|---|
| Elaboration | All specs written Day 1; devs code without QA input. | Just-in-time Three Amigos huddles per story right before pull. |
| Development | Separate backend, frontend, and DB tickets merged on Day 9. | Small end-to-end vertical slices integrated daily via CI. |
| Verification | QA receives 8 stories on Day 9 and works overtime Day 10. | Testing begins Day 1 alongside coding; stories reach Done steadily from Day 2 onward. |
| End-of-Sprint Outcome | Big merge conflicts and unfinished stories carried over. | Multiple cleanly verified stories ready to showcase at Sprint Review. |
6.5 Showcasing and Adapting: Sprint Review and Sprint Retrospective
At the close of every Sprint, Scrum separates inspecting the product (with external stakeholders) from inspecting the team's process (internally) through two distinct events: the Sprint Review and the Sprint Retrospective.
Sprint Review vs. Sprint Retrospective
- Sprint Review: A collaborative working session (max 4 hours for a 1-month Sprint; ~2 hours for a 2-week Sprint) where the Scrum Team demonstrates the Done Increment to Stakeholders, discusses market or technical changes, and adapts the Product Backlog for upcoming Sprints.
- Sprint Retrospective: An internal Scrum Team inspection event (max 3 hours for a 1-month Sprint; ~1.5 hours for a 2-week Sprint) focused on people, interactions, processes, tools, and the Definition of Done, producing concrete improvement actions for the next Sprint.
6.5.1 Running an Effective Sprint Review (Showcasing)
- Show Working Software Only: Never demonstrate slide decks, mockups passed off as working features, or unverified code that fails the Definition of Done. Only Done increments are showcased.
- Two-Way Conversation, Not a Formal Sign-Off: Stakeholders ask questions, try the software, and give candid feedback. The Product Owner uses that empirical evidence to reorder, add, or drop Product Backlog items immediately.
6.5.2 Running an Effective Sprint Retrospective (Adapting)
Great retrospectives rely on psychological safety and Norm Kerth's Prime Directive (assuming everyone did their best given the skills, information, and constraints available at the time—blaming systems, not individuals). Derby and Larsen's five-step retrospective flow keeps the session structured:
- Set the Stage: Open safely and confirm focus.
- Gather Data: Collect objective Sprint facts (velocity, defects, build breaks, timeline) and feelings using formats like Start / Stop / Continue, 4Ls (Liked, Learned, Lacked, Longed For), or Sailboat (wind = helpers, anchor = blockers, rocks = risks).
- Generate Insights: Analyze why bottlenecks or successes happened (e.g., 5 Whys, Fishbone diagram).
- Decide What to Do: Pick 1 to 3 concrete, actionable experiments with clear owners—never a vague wishlist of 15 complaints.
- Close the Retrospective: Capture commitments (often placing top process actions directly into the next Sprint Backlog) and thank the team.
| Aspect | Sprint Review | Sprint Retrospective |
|---|---|---|
| Primary Focus | The Product (Increment, value, market fit) | The Process & Team (workflows, collaboration, tools, DoD) |
| Participants | Scrum Team + Stakeholders / Customers | Scrum Team only (safe internal space) |
| Timebox (1-Month / 2-Week) | Max 4 hours / ~2 hours | Max 3 hours / ~1.5 hours |
| Key Output | Updated Product Backlog and shared stakeholder alignment | 1–3 concrete improvement actions for the next Sprint |
6.6 Agile Quality and Risk: Automated testing, definition of done and failing fast
High delivery speed collapses into chaos if quality erodes. Agile sustains speed indefinitely by building quality directly into engineering workflows (Automated Testing, Definition of Done) and confronting uncertainty early (Failing Fast).
6.6.1 Automated Testing and the Agile Testing Pyramid
Manual regression testing alone cannot keep pace with 1-to-4-week release cycles. Mike Cohn's Agile Testing Pyramid guides how teams balance test speed, cost, and confidence:
/\
/E2E\ <- Fewest: Slow UI / end-to-end journeys + Exploratory testing
/-----\
/ Integ \ <- Moderate: API, service, and database contract tests
/---------\
/ Unit \ <- Base (Most): Fast, isolated tests run on every save/commit
/_____________\- Inverted Pyramid ("Ice Cream Cone") Anti-Pattern: Relying mostly on slow manual UI testing and fragile end-to-end scripts creates multi-day regression bottlenecks and flaky builds.
- Continuous Integration (CI): Every push to main triggers the automated pyramid; if any test fails, fixing the build becomes the team's top priority.
6.6.2 Definition of Done (DoD) vs. Acceptance Criteria
Definition of Done (DoD)
The Definition of Done (DoD) is a formal, team-wide quality checklist that every Increment must meet before it can be demonstrated at Sprint Review or released. When a Product Backlog item does not meet the DoD, it cannot be claimed as Done or counted toward Sprint Velocity.
| Dimension | Acceptance Criteria | Definition of Done (DoD) |
|---|---|---|
| Scope | Specific to one individual User Story | Universal across every item and the whole Increment |
| Defined By | Product Owner + Team (during story refinement) | Whole Scrum Team (and organizational quality/security standards) |
| Examples | "Invalid password shows error; reset token expires in 15 min." | "Peer code reviewed; unit tests >=85%; CI green; zero critical lint/security warnings; docs updated." |
6.6.3 Failing Fast and Empirical Risk Management
Traditional projects hide technical and market risks until late integration or final launch—when fixing a flawed assumption costs 10x to 100x more. Agile manages risk proactively through Failing Fast:
- Timeboxed Technical Spikes: When facing an unfamiliar API, scalability bottleneck, or security library, run a short 1–3 day spike early in Sprint 1 or 2 to test feasibility with real prototype code rather than assuming it works.
- Risk-First Backlog Ordering: Tackle high-risk, high-value architecture and integrations in the earliest Sprints rather than building easy cosmetic screens first.
- Early Market Validation (MVPs & Sprint Reviews): Putting minimal increments in front of real users exposes wrong product assumptions after 2 weeks instead of after 9 months—saving massive wasted engineering budget.
6.4
An engineering team analyzes 50 defects discovered during a 3-month release cycle across three stages with the following average remediation costs:
- Caught early via automated unit/CI tests (during development): 400 USD/defect
- Caught later during late manual QA / pre-release: 1,200 USD/defect
- Escaped to production (customer impact + hotfix): 5,000 USD/defect
Compare two quality profiles on the same 50 defects:
- Weak DoD / Manual QA ("Ice Cream Cone"): 25 caught in dev, 20 in late QA, 5 escaped to production.
- Strong DoD + TDD / Test Pyramid: 42 caught in dev, 6 in late QA, 2 escaped to production.
Calculate total defect remediation cost for both profiles, the total cost saved, and the percentage reduction in defect cost.
Total Defect Cost Under Weak DoD / Manual QA:
- Caught in dev:
25 * 400 = 10,000USD - Caught in late QA:
20 * 1,200 = 24,000USD - Escaped to production:
5 * 5,000 = 25,000USD - Total cost (Weak DoD):
10,000 + 24,000 + 25,000 = 59,000USD.
Total Defect Cost Under Strong DoD + Test Pyramid:
- Caught in dev:
42 * 400 = 16,800USD - Caught in late QA:
6 * 1,200 = 7,200USD - Escaped to production:
2 * 5,000 = 10,000USD - Total cost (Strong DoD):
16,800 + 7,200 + 10,000 = 34,000USD.
Savings and Percentage Reduction:
- Total savings =
59,000 - 34,000 = 25,000USD per release cycle. - Percentage cost reduction =
(25,000 / 59,000) * 100 = 42.37%.
- Weak DoD Cost: 59,000 USD
- Strong DoD + Test Pyramid Cost: 34,000 USD
- Savings: 25,000 USD (42.37% reduction in defect remediation cost)
6.5
Compare the total CI pipeline execution time (in seconds) of two automated test suites where each Unit test takes 0.02 s, each Integration test takes 0.50 s, and each E2E UI test takes 3.00 s:
- Balanced Agile Testing Pyramid (620 tests): 500 Unit tests, 80 Integration tests, and 40 E2E UI tests.
- Inverted "Ice Cream Cone" Suite (440 tests): 120 Unit tests, 100 Integration tests, and 220 E2E UI tests.
Calculate the total execution time in seconds (and minutes) for both suites, and find how many times slower the E2E-heavy suite runs compared to the balanced Pyramid.
Balanced Agile Testing Pyramid Time:
- Unit tests:
500 * 0.02 = 10.0s - Integration tests:
80 * 0.50 = 40.0s - E2E UI tests:
40 * 3.00 = 120.0s - Total runtime:
10.0 + 40.0 + 120.0 = 170.0seconds (2.83minutes).
Inverted ("Ice Cream Cone") Suite Time:
- Unit tests:
120 * 0.02 = 2.4s - Integration tests:
100 * 0.50 = 50.0s - E2E UI tests:
220 * 3.00 = 660.0s - Total runtime:
2.4 + 50.0 + 660.0 = 712.4seconds (11.87minutes).
Speed Comparison:
- Ratio:
712.4 / 170.0 = 4.19times slower—even though the inverted suite runs620 - 440 = 180fewer total tests! Fast feedback loops in CI depend directly on respecting the Testing Pyramid shape.
- Balanced Pyramid (620 tests): 170.0 s (2.83 min)
- Inverted Suite (440 tests): 712.4 s (11.87 min)
- The inverted suite is 4.19 times slower despite running fewer tests.
6.6
Exam-Style Failing Fast & Sprint Ceremonies Question: At the end of Sprint 4, a team holds a combined 45-minute meeting where the Scrum Master shows PowerPoint screenshots of features that "will be tested next week," skips stakeholder Q&A, and spends the final 10 minutes lecturing two developers for breaking a third-party payment gateway integration that was never prototyped beforehand. Identify four Agile violations and prescribe exact fixes across DoD, Sprint Review, Sprint Retrospective, and Failing Fast.
Diagnosing Four Violations:
- Unverified "Done" Work (DoD violation): Showing untested features ("tested next week") violates the Definition of Done and Empirical Transparency.
- Broken Sprint Review: Using PowerPoint screenshots and skipping stakeholder interaction defeats inspecting a working Increment and adapting the Product Backlog.
- Skipped / Blame-Driven Retrospective: Lecturing developers publicly breaks psychological safety, violates the Prime Directive, and omits a separate team-only Sprint Retrospective.
- Failure to Fail Fast: Waiting until Sprint 4 to touch an unfamiliar third-party payment API without an early technical spike turned a cheap early risk into a late Sprint shock.
Prescribing Exact Agile Remedies:
- Definition of Done: Enforce strictly that only fully tested, integrated features appear at Sprint Review; incomplete items return to the Product Backlog.
- Sprint Review: Separate a dedicated interactive session (~2 hours for a 2-week Sprint) where the team demos live working software and gathers stakeholder feedback.
- Sprint Retrospective: Hold a separate, blameless team-only Retrospective (~1.5 hours) using structured reflection (e.g., 4Ls or Start/Stop/Continue) to pick concrete process fixes.
- Fail Fast: Use short Sprint 1–2 technical spikes and automated integration smoke tests whenever adopting external APIs.
The team violated the Definition of Done (untested demo), Sprint Review (slides without live feedback), Sprint Retrospective (omitted and replaced with public blame), and Failing Fast (unvalidated external API risk). Separating Review and Retrospective, enforcing a strict DoD, and running early spikes resolve all four gaps.
Exercises
Practice Exercises — Sprint Execution (Part 2: 6.4–6.6)
Explain the Elaborate -> Develop -> Verify cycle for creating shippable functionality inside a Sprint, and contrast vertical story slicing with a "mini-waterfall" Sprint.
The Story Creation Micro-Cycle:
- Elaborating: Three Amigos (PO, Dev, QA) refine acceptance criteria and edge cases right before work begins.
- Developing: Developers implement thin vertical slices using clean code, reviews, and frequent CI commits.
- Verifying: Automated tests, exploratory QA, and PO confirmation validate every story against acceptance criteria and the DoD inside the Sprint.
Vertical Slicing vs. Mini-Waterfall: In a mini-waterfall Sprint, coding occupies Days 1–8 and all testing piles up on Days 9–10, causing merge chaos and spillover. Vertical slicing completes UI, logic, DB, and tests story-by-story from Day 1, keeping work continuously shippable.
Shippable functionality emerges when each story goes rapidly through Three Amigos elaboration, incremental CI development, and immediate verification—preventing late-sprint testing bottlenecks common in mini-waterfall Sprints.
Compare the Sprint Review and Sprint Retrospective across purpose, participants, timebox, and outcomes, and state Norm Kerth's Prime Directive for retrospectives.
Comparing Sprint Review and Sprint Retrospective:
- Sprint Review: Inspects the working Increment with Scrum Team + Stakeholders (max 4 hrs/month) to gather feedback and adapt the Product Backlog.
- Sprint Retrospective: Inspects people, process, tools, and DoD internally with the Scrum Team only (max 3 hrs/month) to agree on 1–3 concrete improvement actions.
The Retrospective Prime Directive: Regardless of what problems surface, the team affirms that everyone did the best job they could given what they knew, their skills, available resources, and the situation at hand—keeping focus on systemic improvement rather than personal blame.
The Sprint Review involves stakeholders to inspect the working product and adapt the backlog, whereas the Sprint Retrospective is a blameless internal team session (guided by the Prime Directive) to inspect and improve processes, tools, and the Definition of Done.
Draw/describe the Agile Testing Pyramid, explain why an inverted "Ice Cream Cone" test strategy slows Agile teams down, and distinguish between Acceptance Criteria and the Definition of Done (DoD).
Agile Testing Pyramid vs. Ice Cream Cone: The Testing Pyramid has a wide base of fast Unit Tests, a middle layer of Integration/API Tests, and a small peak of E2E/UI Tests (+ exploratory testing). Inverting it into heavy manual/UI testing makes regression slow, brittle, and expensive to maintain inside short Sprints.
Acceptance Criteria vs. Definition of Done:
- Acceptance Criteria: Functional pass/fail conditions unique to one User Story.
- Definition of Done (DoD): Shared, non-negotiable quality checklist applied uniformly to every story and the whole Increment (e.g., code review, coverage, green CI, docs).
The Agile Testing Pyramid emphasizes many fast Unit tests, moderate Integration tests, and minimal E2E UI tests to sustain fast CI feedback (unlike slow "Ice Cream Cone" manual/UI suites). Acceptance Criteria define story-specific behavior, whereas the Definition of Done enforces universal quality standards across the whole Increment.
Explain the Agile principle of Failing Fast, and describe three concrete Agile practices that surface high-severity technical or product risks early.
Concept of Failing Fast: Failing Fast means designing small, inexpensive experiments to test risky technical or business assumptions in Days/Sprints rather than discovering fatal flaws months later after heavy investment.
Three Risk-Surfacing Practices:
- Timeboxed Technical Spikes: Short 1–3 day prototypes early in the project to prove unfamiliar APIs, performance targets, or architecture choices.
- Risk-First Backlog Ordering: Tackling high-uncertainty integrations in early Sprints before polishing low-risk UI screens.
- Frequent MVP Demos & Automated CI: Exposing product usability flaws to real stakeholders at Sprint Reviews and catching code integration defects within minutes on every CI commit.
Failing Fast tests high-uncertainty assumptions early while losses are tiny. Teams achieve this through timeboxed technical spikes, risk-first backlog ordering, and frequent stakeholder Sprint Reviews backed by automated CI.
A development team compares two automated test suites where a Unit test takes 0.01 s, an Integration test takes 0.40 s, and an E2E UI test takes 4.00 s:
- Pyramid Suite (525 tests): 400 Unit, 100 Integration, 25 E2E UI tests.
- UI-Heavy Suite (350 tests): 80 Unit, 90 Integration, 180 E2E UI tests.
Compute the total execution time (in seconds) of each suite, and determine the percentage reduction in CI run time achieved by shifting from the UI-Heavy Suite to the Pyramid Suite.
Execution Time of Both Suites:
- Pyramid Suite:
(400 * 0.01) + (100 * 0.40) + (25 * 4.00) = 4.0 + 40.0 + 100.0 = 144.0seconds (2.40minutes). - UI-Heavy Suite:
(80 * 0.01) + (90 * 0.40) + (180 * 4.00) = 0.8 + 36.0 + 720.0 = 756.8seconds (12.61minutes).
Percentage Time Reduction:
- Time saved =
756.8 - 144.0 = 612.8seconds. - Percentage reduction =
(612.8 / 756.8) * 100 = 80.97%faster CI feedback while running175more tests!
- Pyramid Suite: 144.0 seconds (2.40 min)
- UI-Heavy Suite: 756.8 seconds (12.61 min)
- CI Time Reduction: 80.97% faster execution with the Pyramid Suite.