Why Software Projects Go Over Budget—and How to Reduce the Risk
Software projects usually go over budget because early numbers are treated as certain when they are not. A price is agreed before the work is properly understood, new requirements appear along the way, and integrations, old data and exceptions turn out to be messier than anyone expected. You cannot remove that uncertainty, but you can reduce it before committing, build in small steps so problems show up early, and make every change of scope a conscious decision with a price attached.
How big the risk really is
Bent Flyvbjerg and Alexander Budzier studied 1,471 IT projects for an article in Harvard Business Review. The average cost overrun was 27%, which sounds manageable. But the average hid the real danger: about one project in six was a "black swan", with a cost overrun of 200% on average and a schedule overrun of almost 70%. Their point is that managers who look only at averages miss this risk. For a business owner, the lesson is to plan not only for a project running a little late, but for what would happen if one part went badly wrong – and to structure the work so that one bad part cannot sink everything.
Why early estimates can't be precise
Construx, a software consultancy, explains this with the "Cone of Uncertainty". At the initial concept stage, estimates made even by skilled estimators can be off by a factor of four in either direction – a sixteen-fold range between the lowest and the highest. The cone narrows only as decisions are made that remove variability: defining the product vision (including what you will not do), the requirements and the user interface. Giving the estimator another week does not help much; deciding more things does.
Construx also warns that commitments made too early undermine predictability and increase risk, and that meaningful commitments become possible roughly 30% of the way into a project. So when a one-paragraph brief receives a precise fixed quote, that number is either heavily padded or a guess.
The usual causes of overruns
- Vague goals. "We need a CRM" can mean a shared contact list or a system that runs the entire sales process.
- Scope that grows without trade-offs. Each new idea looks small; together they can double the project.
- Hidden complexity. Integrations with other systems, importing old data, business rules with many exceptions, an old system nobody has documented.
- Late feedback. Users see the software only at the end, when changes are most expensive.
- Slow decisions. Waiting for approvals, content or access to systems costs time even when nobody is working.
- Forgotten "invisible" work. User permissions, security, testing, data migration, deployment and documentation.
- Pressure to quote low. An optimistic number wins the contract and becomes everyone's problem later.
How to reduce the risk before you commit
Start with discovery. The UK government's Service Manual says that before you commit to building a service, you need to understand the problem it should solve: who the users are and what they are trying to achieve, and which constraints exist – legislation, contracts, legacy technology, existing processes. It is explicit that you should not start building during discovery, and that stopping at the end of discovery is not a failure if the research shows that is the best thing to do. For a business, a short, separately priced discovery stage is the cheapest place to learn that a project is bigger, smaller or different than expected.
Write down what is out of scope. A list of things you will not build now narrows the estimate as much as a list of things you will.
Test the riskiest part first. If the project depends on connecting to a courier, a bank or an old database, build a small working connection before committing the whole budget. An integration that works in a test is worth more than ten pages of assumptions.
Separate must-haves from later. A first release with fewer features, used by real people, teaches you more than a complete specification. Our article on defining an MVP without removing what users actually need shows how to cut without cutting the essentials.
How to keep it under control during the work
- Deliver working software often. The principles behind the Agile Manifesto recommend delivering working software frequently, from a couple of weeks to a couple of months, with a preference for the shorter timescale, and treat working software as the primary measure of progress. A status report saying "80% done" is not progress you can test.
- Maximise the work not done. The same principles call simplicity – "the art of maximizing the amount of work not done" – essential. Every feature you drop or postpone is budget you keep.
- Handle changes openly. New ideas are welcome, but each one goes onto a list with an estimate, and you decide what it replaces or whether the budget grows.
- Re-estimate at milestones. As the cone narrows, the estimate should be updated – in both directions.
- Name one decision-maker on your side who can answer questions within a day or two.
Fixed price or time and materials?
| Model | Works well when | Watch out for |
|---|---|---|
| Fixed price | The scope is small and clearly defined | Padding for risk; arguments about what was "included"; resistance to useful changes |
| Time and materials | The scope will evolve and you want flexibility | Needs trust, regular reporting and an agreed budget limit |
| Staged | Larger projects: a fixed price for discovery or the first stage, then an estimate for the next stage based on what was learned | Requires a decision at each stage boundary |
None of these is right for every project. For a small, well-understood piece of work, a fixed price is simple and fair. For anything larger or less clear, splitting the commitment into stages is usually safer for both sides.
Warning signs during a project
- Weeks pass without anything you can click on and test.
- A task has been "almost done" for a long time.
- The list of open questions grows instead of shrinking.
- The riskiest integration still hasn't been tried against the real system.
- Requirements change, but the estimate doesn't.
- The team is waiting for your decisions, content or access.
What you can do as the client
- Prepare a written brief with goals, users and must-have features – the approach in how to write a brief that gets comparable quotes works for software too.
- Ask for estimates as ranges, with the assumptions behind them written down.
- Give access to existing systems and sample data early.
- Test each delivery and give feedback quickly.
- Keep a written list of changes and their effect on cost.
- Budget for running costs after launch – hosting, support and changes – so they don't appear as an "overrun" later.
If you are planning custom software, we can help you define the scope, test the riskiest parts first and split the work into stages, so each estimate rests on known work rather than guesses. Learn more about our web-based software development or contact us with a short description of your project.