Projects

Software projects: stop blaming the estimates

Mohit Saini · 28 Sept 2026 · 5 min read

Software projects: stop blaming the estimates

Industry surveys of software projects have told the same story for decades: a large share run late, cost more than planned, ship with less than promised, or never ship at all. Things have improved over time, but a project delivered on time, on budget and in full scope is still far from the norm.

When a software project slips, the explanation is almost always the same: “The estimates were wrong.” Either they were too aggressive to start with, or the team simply misjudged the work. So the search goes on for a better estimation method, one accurate and objective enough that a team can stand by it, if only customers didn’t keep pushing for tighter dates.

Before we accept that diagnosis, let us question it.

A circular argument

Ask why we are sure the estimates were the problem, and the usual answer is: “The project was late, which proves the estimates were wrong.” That is circular reasoning.

There is another explanation that fits the same facts: a lot of time was wasted along the way, and so nothing was left to absorb the genuine surprises, like extra scope discovered in a task. Project managers readily agree that time is wasted, in other people’s projects. In their own, the team is stretched to the limit.

Can estimates even be accurate?

Estimates are opinions. Most managers privately admit that software estimates are a matter of judgement. There are even theoretical arguments that the complexity of a program can’t be objectively measured before it is written. And when an estimate becomes a commitment, it absorbs other factors too: the developer’s caution, negotiating skill, past experience of being blamed.

Adding up task estimates misleads. Estimation methods usually estimate each task and add them up. But the structure of the project matters:

  • In a chain of tasks, ups and downs tend to cancel out. The longer the chain, the more predictable its total.
  • Where several paths come together, the opposite happens. The joining task can’t start until the latest input arrives. With five parallel inputs, the chance that all arrive on time is far lower than for any one of them. Delays are passed on; gains are lost.

A project with many integration points behaves very differently from a simple chain, yet estimation methods treat them the same.

“Accurate” assumes a true value. Accuracy means closeness to a true value that exists independently of the measurement. But estimates change behaviour: work expands to fill the time (Parkinson’s law), and people start late when there is slack (student syndrome). The estimate influences the outcome. There is no independent “true” duration to be accurate about. And past data, gathered under these behaviours, simply records the self-fulfilling prophecy.

Effort is not what drives the duration

Take any feature and measure its lead time: from the first design work to the moment it passes testing. Then measure the actual working effort on it. Effort is typically a small fraction of the lead time. The rest is:

  • waiting, while the developer switches to something more urgent, waits for an answer or a decision, or the feature sits in a queue for testing;
  • expansion and rework, from starting with incomplete specifications, polishing work until the deadline, or going round in circles on unclear requirements.

Think of taking a car for a service. You drop it off in the morning and collect it in the evening, but the mechanics worked on it for perhaps an hour. The workshop feels flat out all day; your car spent most of the day waiting. Managers usually see projects from the people’s point of view (everyone is busy), not from the work’s point of view (most of the time, nothing is happening to it).

If effort is a small part of lead time, perfecting effort estimates is aiming at the wrong target. The opportunity is in eliminating the waiting.

Predictability without accurate estimates

Customers still need a reliable delivery date. Engineers solved this kind of problem long ago with the factor of safety: an explicit, openly acknowledged margin. Nobody would board a plane designed without one.

Projects need one too, but we are oddly ashamed of it. So safety is hidden inside every task estimate, roughly the difference between a 50% likely duration and a comfortable one, and then quietly consumed.

Critical Chain Project Management makes the safety explicit:

  • Cut task estimates to focused durations (taking a realistic estimate and halving it is good enough).
  • Move the removed safety to a project buffer at the end, and feeding buffers where other paths join the main chain.

Pooled safety protects the whole project with less total time than scattered safety. And since effort is a small share of lead time, there is no need to agonise over estimates.

Four rules for execution

1. Limit work in progress. Too many features open at once means constant switching. Cut work in progress, often by half to start with, and keep it constant: a new feature enters only when one is done. Run frequent integrated builds and tests, so a feature can truly be called done early, and problems don’t pile up before release.

2. Full kit. Features wait in a queue until their specifications are complete. No work starts without them. Ideally, someone other than the developers prepares the kits.

3. Daily active management. With tight task durations, task deadlines can’t be the control point. Review work daily: estimate the remaining time (an estimate, not a promise), clear obstacles, prepare upcoming tasks, and set priorities by buffer impact. The culture shifts from finding someone to blame for a missed date to resolving issues fast.

4. The right measures. Schedule and effort variance (and earned value) reward finishing easy tasks to show progress, while the hard work on the critical chain waits, and bad news arrives at the very end. Instead, measure progress along the critical chain against buffer consumed. Bad news surfaces early, while there is still time to act.

Projects don’t miss dates because the estimates were wrong. They miss dates because time was wasted, and the safety that should have absorbed surprises was hidden and spent.

Software teams that work this way often find they deliver far more within a release than they used to, which raises a pleasant new problem: what to do when you keep beating your own estimates.

Related reading

Mohit Saini

Strategy, supply chain & sales transformation consultant. About · Book a discussion