Custom software projects, from simple to the most complex, often times have one thing in common: they’ve either run over their estimated budget or run out-of-time. Every CEO, CTO, and/or IT Leader wants a clear understanding of the software development budget and timeline to launch and maintain their new business critical technology.
We’ve outlined 3 primary reasons why projects go over their designated software development budget with some tips to get ahead of and control runaway projects.
1. Software projects aren’t scoped right from the outset
One clear way of getting something done within budget is… get the budget right in the first place! It’s incredibly important to ask the right questions in order to understand the technology needs, and to be able to anticipate complications (and opportunity!).
Many companies have a hard time describing what they need in a way that is conducive to getting a good result from a development team, so they need translators — people who can take customer needs and pry them apart, augment and enhance them so that the right solution can be created.
You also need the experience of someone who has been through lots of development projects, and can assess appropriate budget for risks and unknowns — risks driven by things like third-party integrations, and how well-defined (or not) requirements are at the start. This is huge, and leads to our 2nd point…
2. The process isn’t designed to expect the unexpected
All too often, a project that requires development is managed in a way that isn’t designed to be flexible, and there aren’t appropriate expectations set about how to handle the unexpected.
To combat this, it’s important to:
Build contingency into the budget to allow for things not foreseen at the beginning. If you budget purely on the known quantities at the start and expect those to be static, you will lose nearly every time. Much like a home renovation project, there are guidelines for how much contingency you should add in for known quantities. The degree of risk can be assessed by an experienced architect.
Set expectations with stakeholders that things are going to come up mid-project, and the team will need their input to arrive at the best solution. Be flexible; be willing to revisit decisions made during strategy or design when new information comes to light. Ignoring that new information and simply saying to a development team, “That’s the way it was designed, just do it,” pretty much guarantees you’ll blow the budget.
Develop with an iterative process. Do small chunks of deliverable work, and review those with stakeholders every week or two. All too often, organizations will do lots of design up front, then chuck it over to development and say, “Call me when it’s done.” That’s a recipe for disaster. At a minimum you need to have internal review cycles. These interim review points allow for adjustments and problem solving before anything gets too far off course.
3. They don’t have dev leadership
Any highly functional team needs leadership. When an organization doesn’t have development as a core competency, they often aren’t going to have a fully equipped team that includes senior leadership, whose purpose is to both enable developers and be their representative within the organization’s leadership.
What often occurs is that a company will hire a developer or two to do the work, but not a leader who can mentor them, set policy, design/implement processes and best practices, establish performance metrics, and work with other leaders to ensure that other company processes are compatible so that developers can do their best work.
But that leader (and the other roles that make up a well-rounded dev team, like technical project managers, architects, and QA) can be very expensive to hire full-time. In the end, though, because of project budget overruns caused by an absence of those roles, it can be even more expensive to not have it.
The good news is, you can take steps to help ensure projects stay in-budget.
- Ensure technical risks are appropriately assessed and built into the budget.
- Design a flexible process to deal with unknowns and set expectations appropriately.
- Establish strong senior-level engineering leadership that can coordinate efforts with other departments and enhance developer efficiency.