It’s Not Just Bad Luck
If you’ve ever commissioned a software project, you may have heard the familiar refrain: “It took longer and cost more than we expected.” According to McKinsey and the University of Oxford, nearly half of large IT projects run an average of 45% over budget. BCG backs that up, reporting that nearly one in two organisations sees 30% or more of their projects come in late and over budget.
But it doesn’t have to be this way. The real reasons software projects go over budget often go deeper than common explanations. These include “scope creep” or “unexpected complexity”. From our research and real-world experience there’s a range of systemic issues that can quietly derail a budget.
We will be discussing several frequent errors and a famous example. As well as our top tips for managing software delivery that remains within our clients’ budget.
Let’s take a real-world example. The US Department of Defense recently scrapped a long-running project that was meant to modernise its HR systems.
Back in 2018, this programme was pitched as a straightforward upgrade, one year, $36 million. Fast forward to 2025: it has ballooned to over $300 million and still wasn’t finished. After eight years of delays and a 780% overspend, the Pentagon finally pulled the plug.
That’s not just a cautionary tale for governments. Projects in every sector, from fintech and retail to healthcare and logistics, can fall into the same traps.
So how do we avoid budget overruns happening?
Well BCG’s survey helped identify three causes:
- Divergent interests between the business and technology sides of an organisation.
- Resource shortages.
- Unrealistic timelines.
Here are the five key ways we help our clients avoid the classic pitfalls that send software budgets spiralling out of control.
1. Start with Better Scoping & Stick to It
One of the biggest drivers of runaway costs is poor scoping. When project requirements are rushed, unclear, or overly ambitious, budgets are built on shaky ground. Vague goals or a laundry list of features make it difficult to estimate cost or plan delivery with any confidence.
It’s often only partway through development that teams realise they’ve bitten off too much. Even if initially scoped, projects frequently accumulate new requirements during execution. Without strict change control, each added feature inflates cost.
What helps:
- Take the time up front to define a clear scope and stick to it, don’t add anything new yet.
- Prioritise the features that deliver real value – and defer the rest.
- If priorities shift, as they sometimes do, we have regular checkpoints to discuss impacts, costs, and timelines before changes are made.
2. Align Everyone Around the Same Goals
When technical and business teams aren’t pulling in the same direction, things fall apart quickly. For example one side might think the goal is “launching fast,” while the other believes it’s “getting it perfect.” Diverging interests like this creates rework, delays, and budget strain. If executives, product owners, and developers aren’t aligned on why and what is being built, budgets suffer.
What helps:
- Get stakeholders involved early and keep everyone involved. If developers introduce features without frequent demos or reviews by stakeholders, misaligned work may go unnoticed until late stages, requiring costly rework. Remember there’s no such thing as a silly question.
- Use shared success metrics – not just “did we deliver?” but “did it deliver the right thing?”
- Schedule regular checkpoints to make sure expectations haven’t drifted.
- Technology leaders and business managers often speak different languages. Communication gaps means lead to unrealistic expectations of what IT can deliver in a given time and budget
3. Be Realistic About Estimates & Build in Buffer
Budgets often begin with best-case thinking. But software projects rarely follow the ideal path. Delays, bugs, and integration issues are part of the territory. Poor estimation methods are a key factor in cost overruns.
Optimism is one of the most expensive things in software. It’s easy to believe a team can deliver everything in half the time if everyone “just works a bit harder.” But ignoring risk and complexity almost always leads to surprises.
What helps:
- Use historical data, not guesswork, to build estimates.
- Include contingency in the budget – because something will go wrong.
- Be wary of underbidding just to get a green light. It usually costs more in the end.
4. Keep track of Risk Management
Few projects fail from a single big mistake. Instead, they unravel when small problems aren’t addressed early. Small issues can become big blockers fast – a change in regulations, an unexpected integration, a misjudged dependency. Without proper risk planning and contingency, surprises hit the budget hard.
When problems are spotted, teams without a risk management culture may not adjust scope or resources. For example, a firm where developers and managers do not regularly reassess project viability will burn through budget despite mounting red flags.
What helps:
- Risk assessment must be part of the process. Identify your “high-impact, low-likelihood” risks and plan around them.
- Identify blockers early and prepare mitigation strategies. That might mean technical proofs-of-concept, dependency mapping, or phased rollouts.
- Make it culturally acceptable to raise red flags early – not just after the budget’s already blown.
5. Keep the Conversation Going
Poor communication can quietly undo even the best-laid plans. If developers, designers, business owners and stakeholders aren’t talking regularly, assumptions creep in. By the time issues are discovered, it’s often expensive to fix them.
What helps:
- Schedule regular demos or reviews – not just project updates.
- Encourage clear, jargon-free communication.
- Make it easy for people to ask questions, clarify priorities, and flag concerns.
The Bottom Line
Avoiding budget overruns isn’t about following a rigid process or predicting every possible issue. It’s about designing your project in a way that’s flexible, collaborative, and honest from day one.
We’ve worked on projects where staying on budget wasn’t just possible, it was expected. The difference? Strong alignment, smart planning, and a shared commitment to clear communication throughout.
Software projects will always carry some uncertainty. But with the right structure in place, that uncertainty doesn’t need to come with a 780% overspend.
