Agile & Project Management

Agile Estimation and Planning: Points, Velocity and Forecasting

Intermediate7 min readUpdated

Estimates are forecasts about work nobody has done yet, so the useful question is not how to make them accurate but how to make them honest and how to plan with the uncertainty left in. This guide covers relative sizing, planning poker, velocity, throughput-based and Monte Carlo forecasting, release planning and the arguments for dropping estimates entirely.

What you will learn

  • Explain why software estimates are uncertain and what the cone of uncertainty implies
  • Size work relatively with story points and reference stories instead of hours
  • Use velocity as a forecasting input without turning it into a productivity measure
  • Forecast a release from throughput and cycle time, including a probabilistic range
  • Assess where a no-estimates approach genuinely works and where it does not

Every estimate is a statement about work that nobody has done yet, made by people who will learn things during the doing that they cannot know beforehand. This is not a failure of professionalism; it is the definition of the situation. Software estimation is hard because most of the effort goes into discovering what the problem actually is, and that discovery only happens while building.

The useful goal, then, is not accuracy. It is producing forecasts honest enough to make decisions with, cheap enough to be worth the time, and expressed in a way that preserves the uncertainty rather than hiding it behind a single confident number. This guide covers the techniques agile teams use, how to forecast a release without pretending, and what the no-estimates argument gets right. Classic network-based scheduling, which solves a different problem, is covered in schedule management.

Why estimates are uncertain

Three separate sources of error compound.

Ignorance of the problem. Requirements as stated are always an approximation of the need. The gap between them is discovered by building, which means part of the work is unknown at estimation time by definition. This is what the cone of uncertainty describes: at the concept stage, a defensible estimate can be off by a factor of four either way, narrowing as the problem is understood and disappearing only at delivery.

Ignorance of the solution. Nobody knows how ugly the legacy integration is until they open it. Estimates for work in unfamiliar parts of a system are systematically worse than for familiar parts, and the error is asymmetric — surprises make things longer, almost never shorter.

Human bias. People imagine the path where nothing goes wrong, and they anchor on the first number spoken in the room. The tendency to estimate as though the plan will hold is well documented, and the correction is not to demand better guesses but to use observed history from comparable work.

There is a fourth, organisational source: an estimate given under pressure to a stakeholder who wanted a smaller number is a negotiation outcome, not a forecast. Any process that punishes overruns will produce padding, and any process that rewards optimism will produce underestimates.

Relative sizing and story points

Relative estimation sidesteps the hardest question. Humans are unreliable at judging absolute duration and considerably better at comparison: asked whether this item is bigger than that one, a team converges quickly.

A story point is a unit of relative size combining volume, complexity and uncertainty. It has no time value. The scale is usually a modified Fibonacci sequence — 1, 2, 3, 5, 8, 13, 20 — because the growing gaps reflect the fact that precision falls as size rises; distinguishing an 8 from a 13 is possible, distinguishing a 21 from a 23 is not. Some teams use t-shirt sizes for the same reason.

Relative sizing only works with reference stories: two or three finished items the whole team remembers, pinned to specific values. "Adding a required field with validation to the existing form" is a 2; "the CSV import with error reporting" was a 5. New items are placed by comparison. Without references, point values drift over months and any historical data becomes worthless.

Planning poker is the usual mechanism. Each developer holds a card, everyone reveals simultaneously so that nobody anchors on the most senior voice, and the outliers explain their reasoning before a second round. The estimate is a by-product; the conversation is the point, because a wide spread almost always means two people are imagining different scope. For large backlogs, affinity estimation — silently sorting cards on a wall into size groups, then assigning values to the groups — sizes fifty items in an hour with adequate accuracy.

Items estimated at 13 or higher should generally be split before they enter a sprint, using the splitting patterns in the product owner guide.

Velocity, used correctly

Velocity is the number of points the team finishes — meeting the definition of done — in a sprint. Its only legitimate purpose is to help the same team forecast its own future.

Use a range, not an average. A team whose last six sprints delivered 26, 31, 18, 29, 33 and 24 points has an average of 26.8, but planning on 26.8 gives roughly a coin-flip chance of hitting it. Planning the sprint on the low end and forecasting the release with the full spread is far more informative. Never carry velocity across a team change, never compare it between teams, and never publish it as productivity — points are a private unit, and the moment they are rewarded they inflate.

Velocity also degrades quietly when the definition of done is loose, because unfinished work leaks into the count. If velocity is stable but nothing reaches production, the number is measuring activity.

Forecasting from flow

Many teams get better forecasts by ignoring size entirely and counting items.

Throughput is the number of items finished per unit of time. Cycle time is the elapsed time from starting an item to finishing it. Both are measured, not estimated, and both come free from any tool that records state transitions.

The insight behind flow-based forecasting is that item sizes, once a team splits consistently, cluster tightly enough that counting them is about as predictive as summing points — and it costs nothing. If a team finishes between four and nine items per week and eighty items remain, the release lands somewhere between nine and twenty weeks, and you can say so on day one.

Monte Carlo simulation turns that into a distribution. Take the historical weekly throughput samples, draw from them at random repeatedly to simulate completing the remaining items, run ten thousand trials, and read the percentiles.

Remaining items:      80
Weekly throughput samples (last 12 weeks):
  4, 7, 5, 9, 6, 3, 8, 6, 5, 7, 4, 6

10,000 simulated runs — weeks to finish 80 items:
  50th percentile (P50)   13 weeks
  70th percentile (P70)   15 weeks
  85th percentile (P85)   17 weeks
  95th percentile (P95)   20 weeks

Statement to stakeholders:
  "13 weeks is a coin flip. We are 85% confident of finishing
   within 17 weeks. Committing to 20 weeks is safe."

This is a far more useful conversation than "the release is in Q3", because it names the confidence level explicitly and it can be recomputed weekly as real data arrives. Add a scope-growth factor if the backlog historically grows during delivery — a common and often forgotten adjustment.

ApproachInput neededEffortBest for
Story points and velocityTeam estimates every itemMedium, ongoingTeams with mixed item sizes and a sprint cadence
Throughput countingItem start and finish datesAlmost noneTeams that split consistently; flow-based work
Monte Carlo on throughputSame, plus a simple simulationLow, automatableRelease forecasts where a confidence level is required
Three-point estimatingOptimistic, likely, pessimistic per itemHighSmall numbers of large, distinct deliverables
Expert judgement aloneNothingLowRough triage only; not for commitments

The no-estimates argument

A body of practice argues that for many teams estimation is pure overhead. The case is stronger than its critics allow: if items are consistently split small, throughput forecasting gives you the date without any estimation at all, and the hours spent in sizing sessions buy nothing. Estimates also tend to become commitments regardless of how carefully they are framed, which corrupts them.

The counter-arguments are also real. Estimation conversations surface misunderstandings that would otherwise be discovered mid-sprint — the value is in the discussion, not the number. Some decisions genuinely need a cost figure before work starts, such as whether a feature is worth building at all or which of two contract bids to accept. And organisations that fund work annually need something to fund against.

A reasonable position: estimate at the level where the number changes a decision, and stop there. A rough size for a quarterly investment decision is worth producing; re-pointing every item at every refinement session usually is not.

Release planning and capacity

Release planning turns forecasts into a shared expectation. The inputs are the ordered backlog, a forecast range, known fixed dates, and the team's real capacity — not its headcount. Capacity is reduced by holidays, support duty, meetings, onboarding and the share of the sprint reserved for defects, and a team of six rarely has six people's worth of feature time.

Keep the distinction between capacity and commitment sharp. The 2020 framework revision deliberately stopped describing the sprint backlog as a commitment to a set of items and made the sprint goal the commitment instead, precisely because forecast-as-promise had become the dominant misuse. A team forecasts what it expects to finish; it commits to the goal.

For a release, present a range with confidence levels, name the assumptions, and re-forecast every sprint. Where several teams share a release, the coordination overhead changes the picture substantially — see scaling agile. Where the risk of a late date is material, treat it explicitly through risk management rather than by padding estimates invisibly.

Key takeaways

  • Estimates are forecasts made at the point of maximum ignorance; the cone of uncertainty means an early single number is misleading and a range is honest.
  • Relative sizing works because people compare better than they measure absolutely, and it only holds together if the team keeps reference stories.
  • Planning poker exists for the conversation; a wide spread of cards means the scope is understood differently, which is the finding worth having.
  • Velocity is a private, per-team forecasting input expressed as a range — comparing it between teams or reporting it as productivity destroys it.
  • Counting throughput and running a Monte Carlo simulation gives a probabilistic date with confidence levels for almost no ongoing cost.
  • Estimate where the number changes a decision; commit to the sprint goal rather than to a list of items, and re-forecast as real data arrives.

Sources and further reading

Frequently asked questions

Why not just estimate in hours or days?
Because time estimates invite two mistakes. They are read as commitments by everyone outside the team, and they mix the size of the work with the speed of the individual doing it, so the same task gets three different numbers depending on who answers. Relative sizes separate those concerns: the team agrees how big a thing is, and observed throughput supplies how long things of that size actually take.
Should story points be converted into days for reporting?
Avoid it. The moment a point has an official hour value, the abstraction is gone and the team is back to time estimates with an extra translation step, plus a strong incentive to inflate. If a stakeholder needs a date, give them a date derived from measured throughput with a confidence level attached, not a points-to-days conversion.
How many sprints of data do you need before a forecast is meaningful?
Somewhere between six and ten completed sprints, or roughly thirty finished items if you are forecasting from throughput. Fewer than that and the range is dominated by noise. Use the most recent data rather than a long average, because team composition, product maturity and codebase health all shift, and a year-old sprint tells you little about the current one.
What is the cone of uncertainty?
It is the observation that estimate error narrows as a project progresses. At the earliest concept stage a genuine estimate might be off by a factor of four in either direction; by the time requirements are understood the spread is much narrower; near the end it is small. The practical consequence is that a single-number estimate made at the start is misleading, and any early figure should be given as a range.