8 min

Sprint Spillover: What Carryover Work Reveals About Delivery Predictability

Why work items cross sprint boundaries, what rollover truly signals about your delivery system, and how to improve stability without falling into binary success traps.

At the end of a sprint, seeing tickets roll into the next iteration (spillover or carryover) often triggers two extreme reactions: blame or resignation. A rollover is first and foremost a signal about the working system — useful for choosing concrete improvements when examined with facts rather than treated as fault.

The essentials in 30 seconds

  • Spillover is a system signal, never an automatic failure or individual fault: an occasional rollover reflects normal uncertainty, while recurring rollovers point to flow instability.
  • Check the facts before concluding: separate initial scope, mid-sprint additions, blockers, and ticket sizing — and remember the team commits to the Sprint Goal, not 100% of backlog tickets.
  • Act on workflow rather than chasing 0% spillover: capping Work in Progress (WIP), slicing smaller, and keeping reviews moving stabilizes iterations far better than rigid targets that distort data.

1. What Spillover Does and Does Not Tell You

In software delivery, an item is considered spilled over (or carried over) when it is accounted for in a given iteration and remains unresolved beyond that iteration's timebox boundary. Most often it moves from Sprint N to Sprint N+1, though persistent items can cross multiple iteration boundaries before completion.

Flow Dynamics: Completed Work vs. Carried Over Work (Spillover)
Sprint N (Source Iteration)Initial scope: 3 items
Ticket A (User Story)
Done (0 rollover)
Ticket B (Architecture)
Incomplete → Spillover
Ticket C (API Endpoint)
Done (0 rollover)
Sprint N+1 (Next Iteration)Committed: 3 items
Ticket B (Carryover)
Done (1 rollover)
Ticket D (New Feature)
Done (0 rollover)
Ticket E (Frontend UI)
In Progress

Ticket B crossed the boundary of Sprint N before completion: it is tracked as 1 rollover once finished in Sprint N+1.

Four distinct operational realities can sit behind the exact same rollover number:

In-flight work not finishedDevelopment started, but the item could not clear every validation step (review, QA, release) before sprint close.
Unstarted work postponedThe ticket sat in the initial plan but was never started due to capacity constraints.
Mid-sprint story splittingPart of the value was delivered while the remaining scope was split into a follow-up ticket.
Deliberate deprioritizationThe ticket was intentionally paused to handle a production incident or higher-value discovery.

Why Spillover Is Not Automatically a Failure

Uncovering hidden complexity, refusing to skip testing to meet a sprint deadline, or absorbing an urgent incident are rational decisions in favor of quality. A team with zero spillover every sprint may simply be under-committing heavily or closing unfinished work administratively.

The useful question is not whether a rollover happened once, but whether it stays rare or becomes a recurring pattern.

Sprint Goal vs Ticket Selection (Scrum Guide)

The Scrum Guide (2020) clarifies that the team's commitment is to the Sprint Goal (the business value objective of the sprint), while the Sprint Backlog remains an adaptable forecast.

Completing every Sprint Backlog item does not prove value was delivered if the goal was missed. Conversely, a sprint can achieve its Sprint Goal while carrying some items over: spillover alone is therefore not enough to conclude that the sprint failed.

Initial Scope vs Final Scope

Judging a sprint solely by its final state hides mid-sprint entries and exits. It helps to distinguish five ticket populations:

Initial planned scopeItems selected during sprint planning.
Mid-sprint additionsUnplanned production bugs, urgent requests, or newly discovered tasks.
Removed or canceled itemsTickets explicitly dropped with the Product Owner to protect the Sprint Goal.
Completed work (Done)Tickets meeting the Definition of Done before sprint close.
Carried over work (Spillover)Tickets still open at the end of the iteration.

Completing 10 out of 12 initially planned items is a very different situation from completing 10 items after absorbing 6 unplanned mid-sprint additions.

2. Concrete Example and the Role of Variability

Let us examine a fictional 2-week sprint:

Initial planned scope
12 tickets
Unplanned mid-sprint additions
+3 tickets
Total scope managed
15 tickets
Completed on time
10 tickets (8 from initial scope + 2 added)
Carried over to next sprint
4 tickets (2 initial + 1 added + 1 blocked)
Removed / dropped items
1 ticket
Summarizing this sprint as "10 out of 15 completed (66.7%)" hides the real story: 3 tickets were added mid-sprint (25% of the 12 originally planned), of which 2 were completed and 1 was carried over, while 1 ticket was removed. Diagnosis should separate team delivery capacity from sprint boundary permeability.

Predictability and Outcome Variability

In software delivery, predictability does not mean certainty or rigid plans: a system is more predictable when its outcome variability is understood and narrow enough to inform dependable decisions.

Why Averages Alone Can Mislead

Compare two teams across 5 consecutive sprints:

Team A — Completion Rate: 82%, 84%, 81%, 83%, 82% (Mean = 82.4% | Standard Deviation = 1.1%)
Team B — Completion Rate: 100%, 60%, 95%, 55%, 100% (Mean = 82.0% | Standard Deviation = 22.5%)
Despite nearly identical averages (82.4% vs 82.0%), Team A's observed completion rates are much more stable across these five sprints, while Team B shows substantially greater variability. This short series illustrates a difference in observed stability; by itself, it is not enough to establish the long-term predictability of either system.

Stability measures output consistency over an observed window — not speed or business value.

3. Possible Causes and Clues to Tell Them Apart

A high rollover rate never proves a single root cause. Treat these six causes as hypotheses to test against evidence (timestamps, ticket size, mid-sprint additions) without mistaking correlation for certainty:

Excessive Work in Progress (WIP)

Hypothesis: Too many items advance in parallel, increasing context switching.
How to check: Check concurrent open items against team size and experiment with WIP limits.

Oversized Tickets (Insufficient Slicing)

Hypothesis: Some tickets exceed the practical sprint runway or conceal hidden complexity.
How to check: Compare active duration of rolled-over items vs completed ones and slice stories into smaller vertical increments.

Late Starts Inside the Sprint

Hypothesis: Items are only picked up during the final 2 or 3 days, leaving too little runway for review and testing.
How to check: Check the start dates of carried-over items and avoid launching large stories near sprint close.

Code Review or QA Bottlenecks

Hypothesis: Coding wraps up early, but tickets pile up waiting for review or verification.
How to check: Inspect time spent in intermediate workflow stages and prioritize reviews over opening new tickets.

Unplanned Scope and Interruptions

Hypothesis: Production incidents or urgent stakeholder requests regularly absorb planned capacity.
How to check: Track the share of mid-sprint additions and agree on an explicit trade-off rule (one urgent item in, one planned item out).

Unclear Criteria or External Dependencies

Hypothesis: A third-party dependency or missing acceptance criterion only surfaces mid-flight.
How to check: Verify blocking prerequisites before pulling work into the sprint (Definition of Ready / Done).

Cross-Check with Active Flow Duration (Cycle Time)

Spillover only takes a snapshot at sprint close. Checking the active duration (Cycle Time) of rolled-over tickets helps distinguish a flow or queue problem from a late start.

If carried-over items consistently show much longer Cycle Times than other tickets, the highest-leverage levers are usually slicing, reviews, or WIP limits.

4. Actions and Experiments to Try

Instead of imposing a hard metric target, run one or two focused experiments over 2 to 3 sprints and observe what changes:

1. Cap Work in Progress (WIP)Favor "stop starting, start finishing" over keeping many tickets open at once.
2. Slice Work into Small Vertical IncrementsAim for tickets that can be built and verified in a few days to reduce boundary rollover risk.
3. Keep Reviews and QA Moving DailyAvoid end-of-sprint review pileups by treating pull request reviews as a daily priority.
4. Make Trade-Off Rules Explicit for Urgent WorkReserve explicit buffer capacity or agree on which item moves out when an urgent task enters.
5. Walk Through 2 or 3 Rolled-Over Tickets BlamelesslyIn retrospectives, trace where those items waited and what would have surfaced the blocker earlier.

The 0% Spillover Trap (Goodhart's Law)

Goodhart's Law states that "when a measure becomes a target, it ceases to be a good measure." Demanding 0% spillover encourages under-commitment, cosmetic ticket splitting on the last day, or closing items without thorough verification.

Once gamed, the rollover signal loses all diagnostic value.

5. Data and Calculation Limitations

In Jira exports, a ticket spanning several iterations often appears with multiple "Sprint" columns. Reconstructing rollovers from raw exports has real technical limits:

  • Multiple Sprint columns do not guarantee chronological order without cross-checking actual sprint start and end dates.
  • A ticket can be assigned administratively to a sprint without any active work occurring during it.
  • Without a completion date (Resolved) or with ambiguous sprint boundaries, the completion sprint cannot be determined reliably.
  • Technical or buffer sprints (backlog parking lots) must be excluded so they do not skew team metrics.

Reliable analysis depends on actual timestamps and verified sprint bounds, never on sprint name strings alone.

Item Count vs Actual Effort

Measuring spillover by ticket count (item count) gives a clean flow signal, but 2 rolled-over tickets out of 20 can represent most of the remaining complexity if sizing is highly uneven.

Story Points do not eliminate that uncertainty either: the most practical approach is to track ticket counts while keeping story slicing reasonably consistent.

How Cauba Analyzes Iteration Rollover

Cauba applies a 100% deterministic method without fabricating missing data:

  • Bucket classification: completed tickets in the analysis window are grouped by exact observed rollovers (0 rollovers, 1 rollover, or 2+ rollovers).
  • Explicit unavailable reasons: if a completion date is missing or sprint boundaries are ambiguous, the ticket is flagged unavailable with the exact reason.
  • Exclusion of non-analytical iterations: you can exclude technical or outlier sprints to protect analytical integrity.
  • Reading it in the diagnosis: this rollover breakdown (0, 1, or 2+ rollovers) appears in the team's detailed report so you can see whether spillover stays occasional or becomes recurrent.

Cauba never produces an arbitrary sprint pass/fail score: it gives factual visibility into workflow stability.

Cycle Time vs Lead Time: Definitions and Formulas

Understand how measuring cycle time and leveraging percentiles (P50, P85) secures your sprint delivery.

Preparing a Jira Export to Analyze Software Delivery Flow

Complete walkthrough to export a clean CSV with sprints and statuses, ready for Cauba flow analysis.

Moving from Estimates to Forecasts Grounded in Real Delivery Data

Distinguish estimates, forecasts, targets, and commitments, and ground your delivery projections in observed throughput and its variability.

Frequently Asked Questions (FAQ)

It is a work item accounted for in an iteration that stays unresolved beyond sprint close — whether carried into the next sprint (N+1) or spanning multiple iterations.

Methodological References & Further Reading

  • Ken Schwaber & Jeff Sutherland — The Scrum Guide (2020). Clarifies the Sprint Goal as the core commitment and the Sprint Backlog as an evolving forecast.
  • Daniel S. Vacanti — Actionable Agile Metrics for Predictability (2015). Foundational text on flow stability, WIP limits, and probabilistic forecasting.
  • David J. Anderson — Kanban: Successful Evolutionary Change for Your Technology Business (2010). Principles of bottleneck management and controlling work in progress.
  • Klaus Leopold — Rethinking Agile (2018). Systems thinking approach to cross-team dependencies and organizational delivery delays.