Sprint Execution and Quality Management (part 1: 6.1–6.3)
Open in the Padhaiko app6.1 Sprint Planning: Backlog creation, task identification, and timeboxing
Every Sprint begins with Sprint Planning, the collaborative event where the Scrum Team turns prioritized Product Backlog items into an actionable, timeboxed execution plan anchored by a single Sprint Goal.
Sprint Planning and the Three Core Topics
Sprint Planning initiates the Sprint by laying out the work to be performed. The resulting plan is created by the collaborative work of the entire Scrum Team and addresses three topics:
- Topic 1 — Why is this Sprint valuable? The Product Owner proposes how the product could increase value; the whole Scrum Team collaborates to craft a clear Sprint Goal communicating why the Sprint matters to stakeholders.
- Topic 2 — What can be Done this Sprint? Developers select Product Backlog items (PBIs) from the top of the ordered backlog based on past performance (velocity), upcoming team capacity, and the Definition of Done. Only the Developers decide how much work they can commit to.
- Topic 3 — How will the chosen work get done? For each selected story, Developers decompose the work into concrete engineering tasks (coding, unit tests, API integration, code review, QA verification) needed to produce a Done Increment.
6.1.1 Sprint Backlog Creation and Task Identification
- Inputs to Sprint Planning: A refined Product Backlog (stories meeting the Definition of Ready), the team's recent Velocity range, individual Sprint Capacity (net available hours after subtracting holidays, leave, and Sprint ceremonies), and the Definition of Done.
- Task Identification Rules:
- Keep tasks small—ideally 4 to 16 hours (half a day to two days) so progress is visible daily.
- Cover every activity needed for Done (database migration, UI, automated tests, documentation, deployment prep)—not just "write code."
- Double-Check Velocity vs. Capacity: A team's historical velocity (e.g., 30 Story Points) provides a macro guide; summing estimated task hours against net team hours confirms whether 30 points genuinely fits this specific Sprint (for instance, if two members are on leave).
6.1.2 Timeboxing Sprint Planning
| Sprint Duration | Maximum Sprint Planning Timebox | Typical Practical Split (Why / What / How) |
|---|---|---|
| 1-Week Sprint | Max 2 hours | ~20 min Goal & Capacity -> ~40 min Story Selection -> ~60 min Task Breakdown |
| 2-Week Sprint | Max 4 hours | ~30 min Goal & Capacity -> ~90 min Story Selection -> ~120 min Task Breakdown |
| 3-Week Sprint | Max 6 hours | ~45 min Goal & Capacity -> ~2 hrs Story Selection -> ~3.25 hrs Task Breakdown |
| 4-Week (1-Month) Sprint | Max 8 hours | ~1 hr Goal & Capacity -> ~3 hrs Story Selection -> ~4 hrs Task Breakdown |
- Why Timeboxing Matters: A strict timebox prevents "analysis paralysis" during planning. If the team prepares stories beforehand in Backlog Refinement, Sprint Planning finishes easily within its timebox.
6.2 Daily Scrum: Planning the day and identifying roadblocks
The Daily Scrum (often called the daily stand-up) is a fast, tactical synchronization event held at the same time and place every working day of the Sprint.
Daily Scrum Purpose and Rules
The Daily Scrum is a 15-minute timeboxed event for the Developers of the Scrum Team. Its sole purpose is to inspect progress toward the Sprint Goal, adapt the Sprint Backlog as necessary, and adjust the upcoming planned work for the next 24 hours.
6.2.1 Formats and Roadblock Identification
Developers may choose any structure as long as it focuses on progress toward the Sprint Goal and actionable next steps. Two widely used formats are:
- Classic Three-Question Walk-Through (per developer):
- What did I complete yesterday that helped the team meet the Sprint Goal?
- What will I work on today to help the team meet the Sprint Goal?
- Do I see any impediment (roadblock) preventing me or the team from meeting the Sprint Goal?
- Walking the Board (Right-to-Left):
- Instead of going person-by-person, the team scans the Task Board starting from the rightmost active column (e.g.,
Testing / Review->In Progress->To Do). - Focuses everyone on finishing work already close to Done rather than starting new tasks, reinforcing Kanban WIP discipline and team swarming.
- Instead of going person-by-person, the team scans the Task Board starting from the rightmost active column (e.g.,
6.2.2 Common Daily Scrum Anti-Patterns vs. Best Practices
| Dimension | Healthy Daily Scrum | Common Anti-Pattern |
|---|---|---|
| Audience & Ownership | Peer-to-peer coordination by Developers; PO/SM attend if helpful. | Treated as a status report to the Scrum Master or manager ("reporting up"). |
| Timebox Discipline | Strictly 15 minutes; deep technical debates move to an immediate "16th-minute" after-party. | Drags to 45 minutes solving architecture details while uninvolved teammates stand waiting. |
| Impediment Handling | Blockers are flagged visibly right away; Scrum Master or teammate pairs to resolve them immediately after. | Developers hide blockers ("still working on it") to avoid looking slow. |
6.3 Tracking Progress: Task boards, burndown charts, and information radiators
Agile rejects opaque "percent-complete" status spreadsheets in favor of visual, empirical progress tracking where anyone can inspect real Sprint health in seconds.
6.3.1 Sprint Task Boards
A Sprint Task Board makes every selected User Story and its underlying tasks visible across workflow columns:
+----------------------+-------------+---------------+---------------+-------------+
| Story (Sprint Goal) | To Do | In Progress | Review / Test | Done |
+----------------------+-------------+---------------+---------------+-------------+
| Story A: User Login | [UI tests] | [Auth API] | [DB schema] | [Wireframe] |
| | | (Dev: Maya) | (QA: Arun) | |
+----------------------+-------------+---------------+---------------+-------------+
| Story B: Reset Link | [Token API] | [Email job] | | |
| | [Unit test] | [BLOCKED:SMTP]| | |
+----------------------+-------------+---------------+---------------+-------------+- Swarming Signals: Seeing cards pile up in
Review / Testtells Developers immediately to pause picking newTo Dotasks and help clear the review/testing bottleneck.
6.3.2 Burndown Charts (and Burnup Comparison)
Sprint Burndown Chart
A Sprint Burndown Chart plots Remaining Work (either remaining Story Points or remaining estimated task hours on the vertical axis) against Sprint Days (on the horizontal axis). It compares an Ideal Burndown Line (steady linear burn from initial commitment down to 0) against the Actual Remaining Work updated daily.
| Visual Pattern on Chart | Likely Root Cause | Recommended Team Action |
|---|---|---|
| Actual closely tracks Ideal line | Stories are well-sliced; tasks finish and verify steadily throughout the Sprint. | Maintain current WIP discipline and continuous testing cadence. |
| Flat plateau for several days, then steep drop | Stories are too large, developers wait until late to test ("mini-waterfall"), or tasks aren't updated daily. | Split stories smaller (INVEST) and enforce daily vertical completion. |
| Actual line spikes upward mid-Sprint | Unplanned scope was added mid-Sprint or a task was severely underestimated. | Protect Sprint scope via the PO; adjust Sprint Backlog collaboratively to guard the Sprint Goal. |
| Actual line stays flat above zero near end | Hidden external blocker or overly optimistic commitment at Sprint Planning. | Swarm immediately on highest-value Sprint Goal items and drop lower-priority stories back to Product Backlog. |
- Burndown vs. Burnup Charts: At the Release level, Burnup Charts plot two separate lines—Total Scope and Cumulative Completed Work—making it immediately obvious whether a delayed forecast came from slower team velocity or from stakeholders adding extra scope.
6.3.3 Information Radiators
Coined by Alistair Cockburn, an Information Radiator is any highly visible, constantly updated physical or digital artifact placed where team members and stakeholders naturally see it without asking for status reports.
- Key Characteristics of a Good Information Radiator:
- Glanceable: Readable from across the room or dashboard in 5 seconds.
- Honest and Current: Updated continuously (automatically by CI/CD or daily by the team).
- Minimal Effort to Maintain: Radiates empirical truth without creating administrative overhead.
- Common Examples: Sprint Task Board, Sprint/Release Burndown & Burnup charts, automated Build/CI Monitor (green/red build status), test coverage trends, open blocker list, and the posted Definition of Done.
6.1
A 5-developer Scrum team plans a 2-week (10-working-day) Sprint. After accounting for Sprint ceremonies and company holidays, each developer has 8 active project days at 6 productive hours per day (5 * 8 * 6 = 240 gross hours). Subtract 20 hours of planned individual leave, and apply an empirical 0.75 focus factor to buffer unplanned bug fixes and support interruptions.
- Four prioritized candidate stories from the Product Backlog have task-hour estimates:
- Story A (Priority 1): 48 task hours
- Story B (Priority 2): 40 task hours
- Story C (Priority 3): 52 task hours
- Story D (Priority 4): 36 task hours
- Calculate the team's net available Sprint task capacity (in hours).
- Determine how many of the four prioritized stories fit safely inside the Sprint capacity, and compute the remaining buffer hours.
Calculating Net Sprint Capacity:
- Gross focus hours before leave =
5 developers * 8 active days * 6 hours/day = 240hours. - Subtracting 20 hours of planned leave =
240 - 20 = 220.0hours. - Applying the 75% empirical focus factor (accounting for code reviews, Slack support, and unexpected impediments):
Net Task Capacity = 220.0 * 0.75 = 165.0task hours.
Selecting Stories Against Capacity: Total hours for all 4 stories = 48 + 40 + 52 + 36 = 176.0 hours, which exceeds the 165.0-hour capacity by 11.0 hours. Packing in strict priority order:
- Story A (
48hrs) + Story B (40hrs) + Story C (52hrs) =140.0task hours (<= 165.0hrs). - Adding Story D (
36hrs) would reach176.0hours (> 165.0), creating high burnout/spillover risk. - Remaining buffer after selecting Stories A, B, and C =
165.0 - 140.0 = 25.0hours.
- Net Sprint Task Capacity: 165.0 hours
- Recommended Sprint Commitment: Stories A, B, and C (140.0 hours), leaving 25.0 hours of healthy contingency buffer (Story D remains at the top of the Product Backlog for the next Sprint).
6.2
A Scrum team commits to 100 Story Points for a 10-working-day Sprint (Day 0 = 100 points remaining; ideal finish at Day 10 = 0 points remaining). At the end of Day 5 (halfway through the Sprint), the team has burned down only 36 points, leaving 64 Story Points remaining.
- Calculate the ideal remaining points at Day 5 and the schedule variance (points behind the ideal line).
- Compute the team's actual burn rate (points/day) over Days 1–5 versus the required burn rate (points/day) over Days 6–10 to still finish all 100 points on Day 10.
- Recommend two concrete Agile responses rather than demanding weekend overtime.
Ideal Remaining Work and Schedule Variance at Day 5:
- Ideal burn rate =
100 points / 10 days = 10.0points/day. - Ideal remaining points at Day 5 =
100 - (10.0 * 5) = 50.0points. - Variance behind ideal line =
64 - 50.0 = 14.0points behind schedule.
Actual vs. Required Burn Rate:
- Actual points completed in Days 1–5 =
100 - 64 = 36points -> Actual burn rate =36 / 5 = 7.2points/day. - Remaining work for Days 6–10 =
64points over5days -> Required burn rate =64 / 5 = 12.8points/day (nearly78%faster than Days 1–5!).
Empirical Agile Responses:
- Inspect blockers & swarm: Check the Task Board in Daily Scrum to see if stories are stuck in
Review / Testing(meaning actual delivery will jump once reviews clear) and swarm on finishing active items instead of starting new ones. - Negotiate scope with Product Owner to protect the Sprint Goal: If
12.8points/day is unrealistic at a sustainable pace (Principle 8), collaborate with the PO immediately to defer the lowest-priority non-goal story back to the Product Backlog so the core Sprint Goal ships cleanly with full DoD quality.
- Ideal at Day 5: 50.0 points; Behind ideal by: 14.0 points.
- Actual burn rate (Days 1–5): 7.2 points/day; Required burn rate (Days 6–10): 12.8 points/day.
- Response: Swarm on nearly-Done stories stuck in review/QA, and collaborate with the Product Owner to drop lower-priority scope rather than sacrificing quality or sustainable pace.
6.3
Exam-Style Daily Scrum & Tracking Question: During a team's Daily Scrum, all 7 developers spend 35 minutes speaking sequentially to the Scrum Master, explaining detailed SQL index tuning choices, while three stories sit untouched in the Ready for QA column for four days. Identify three process dysfunctions shown here and explain how to fix each one using Agile practices.
Diagnosing Three Dysfunctions:
- Timebox & Focus Failure (35-min technical deep-dive): Daily Scrum exceeds its 15-minute cap by diving into implementation debates irrelevant to the whole team.
- Reporting-to-Boss Anti-Pattern: Addressing the Scrum Master instead of collaborating peer-to-peer turns a planning event into upward status reporting.
- Ignoring Board Bottlenecks (No Swarming): Three stories piling up in
Ready for QAfor four days shows developers starting new tasks instead of inspecting flow on the Task Board.
Concrete Fixes:
- Switch to Walking the Board (right-to-left) so the team inspects
Ready for QAfirst and pairs developers with QA to finish blocked stories before pulling newTo Dowork. - Move SQL index debates to a "16th-minute" side conversation immediately after the 15-minute Daily Scrum with only the interested developers.
- Have Developers speak directly to one another around the Sprint Goal while the Scrum Master facilitates timeboxing and removes external blockers.
The team suffers from timebox blowout, upward status reporting, and unmanaged QA bottlenecks. Fixes include 15-minute peer-to-peer coordination with a 16th-minute parking lot for technical details and Walking the Board right-to-left to trigger immediate swarming on Ready for QA stories.
Exercises
Practice Exercises — Sprint Execution (Part 1: 6.1–6.3)
Describe the three key questions answered during Sprint Planning (Why, What, How), list its required inputs, and explain why Sprint Planning is strictly timeboxed.
Three Sprint Planning Topics and Inputs:
- Inputs: Ordered, refined Product Backlog, team historical velocity, net Sprint capacity, and Definition of Done.
- Why: Whole team defines the Sprint Goal explaining the Sprint's business value.
- What: Developers select realistic Product Backlog items based on velocity and capacity.
- How: Developers break selected stories into small engineering and testing tasks (Sprint Backlog).
Purpose of Timeboxing: Capping Sprint Planning (max 8 hours for a 1-month Sprint, ~4 hours for a 2-week Sprint) forces concise refinement beforehand, prevents endless upfront micro-design, and keeps the team focused on starting empirical execution quickly.
Sprint Planning uses backlog priorities, velocity, capacity, and DoD to establish Why (Sprint Goal), What (selected PBIs), and How (task breakdown). Strict timeboxing prevents analysis paralysis and reinforces iterative discovery during the Sprint.
Explain the purpose, participants, and 15-minute rule of the Daily Scrum, and contrast the Three-Question format with Walking the Board.
Purpose, Participants, and Timebox: The Daily Scrum is a 15-minute daily synchronization for Developers to inspect Sprint Goal progress, adapt the next 24 hours' plan, and surface blockers early (moving deep debates to a post-stand-up "16th minute").
Three Questions vs. Walking the Board:
- Three Questions: Each developer shares yesterday's completed work, today's target, and any blockers—easy for new teams, though it can drift into individual status updates.
- Walking the Board (Right-to-Left): Team scans active board items closest to
Donefirst, highlighting stalled tickets, code review queues, and immediate swarming opportunities.
The Daily Scrum is a 15-minute Developer event to adapt the 24-hour Sprint plan and spot blockers. While the Three Questions focus per person, Walking the Board inspects tickets right-to-left to prioritize finishing nearly-Done work and clearing flow bottlenecks.
Define an Information Radiator and explain how a Sprint Task Board and Sprint Burndown Chart jointly promote empirical transparency.
Information Radiator & Visual Tools: An Information Radiator is a highly visible, live display (physical wall or shared monitor) communicating real project status at a glance without formal status reports.
- Sprint Task Board: Shows story/task workflow state (
To Do | In Progress | Review/Test | Done), WIP bottlenecks, and blocked cards in real time. - Sprint Burndown Chart: Compares remaining points/hours daily against the Ideal line, exposing flat plateaus, scope spikes, or late-sprint risk early.
Joint Impact on Transparency: Together, the Task Board explains where work is stuck today while the Burndown Chart reveals whether overall Sprint pace is on track—enabling immediate daily inspection and adaptation.
An Information Radiator openly displays live team status at a glance. The Task Board exposes active workflow bottlenecks and blockers, while the Burndown Chart tracks remaining work against time—jointly providing real-time empirical transparency.
Contrast a Sprint Burndown Chart with a Release Burnup Chart, and describe what a flat plateau followed by a sharp drop on Day 9 in a 10-day Sprint Burndown indicates.
Burndown vs. Burnup Charts:
- Sprint Burndown: Tracks remaining work sloping down toward
0; simple for a fixed Sprint, but cannot easily distinguish added scope from stalled velocity. - Release Burnup: Plots cumulative completed work rising upward alongside a separate Total Scope line, making scope creep vs. delivery pace immediately distinct.
Interpreting a Flat Plateau + Day 9 Drop: Remaining points stay flat for 8 days and plummet on Day 9 when stories are too large ("mini-waterfall" coding all week and testing on Day 9), tasks aren't split vertically, or board updates are neglected—creating severe end-of-sprint defect risk.
A Burndown tracks remaining work downward, whereas a Burnup separates cumulative work done from total scope changes. A flat plateau dropping sharply on Day 9 signals oversized stories, batched late testing ("mini-waterfall"), or neglected daily tracking.
A team runs an 8-working-day Sprint starting with 80 Story Points on Day 0. At the end of Day 3, 65 Story Points remain on the Sprint Burndown Chart.
- Calculate the ideal remaining points at Day 3 and how many points behind the ideal line the team is.
- Compute the team's actual burn rate (points/day) during Days 1–3 and the required burn rate (points/day) across Days 4–8 to hit 0 points on Day 8.
Ideal Remaining Points and Variance at Day 3:
- Ideal daily burn =
80 / 8 = 10.0points/day. - Ideal remaining at Day 3 =
80 - (10.0 * 3) = 50.0points. - Schedule variance =
65 - 50.0 = 15.0points behind the ideal line.
Actual vs. Required Burn Rate:
- Points completed in Days 1–3 =
80 - 65 = 15points -> Actual burn rate =15 / 3 = 5.0points/day. - Remaining days =
8 - 3 = 5days -> Required burn rate =65 / 5 = 13.0points/day.
- Ideal at Day 3: 50.0 points (15.0 points behind ideal).
- Actual burn rate: 5.0 points/day; Required burn rate (Days 4–8): 13.0 points/day.