Failure… It’s a word no one ever wants to hear, and yet it happens all too often when software development projects go awry. While it is a broad term, the idea of “failure” can mean different things… going over budget, delivering the end result later than expected, creating a product that isn’t up to expected quality, or most importantly: developing a product that ends up never getting used.
Who is to blame when software projects fail? We’re quick to lay eyes on the development team, but poor overall business decision making is usually the major culprit that cripples a project from the start. Let’s take a look at some of the top reasons that software projects end up failing, and what can be done to prevent these issues.
The Top 7 Reasons Why Software Projects Fail
1. Unrealistic expectations.
When it comes to software projects, the most important thing is to not come in with preconceived notions about the difficulty of the project. Take for example a company that wants to make a simple mobile app. They assume it will cost them $5000, and require a couple week’s worth of work to complete the features they want. The company may think this is easy to accomplish, and knows how the project timeline will play out. In reality, the project may take significantly longer than anticipated and require a larger budget!
2. Budget planning.
Speaking of budgets, cost is an important factor that can make or break a project. The lowest bidder isn’t necessarily your best choice when choosing a company to work with. Instead, your selection should be based on the track record of the company in delivering results. Keep in mind that if your budget is unrealistic compared to the work you want done, you’re going to be cutting corners in some respect when it comes to quality.
3. Scope creep.
Have you experienced this scenario? Your software project is underway, with the features and requirements outlined. Suddenly, your team starts using sentences, such as:
“Wouldn’t it be cool if…”
“That’s not gonna work…”
“We should also do this…”
That is what we refer to as scope creep. In layman’s terms, it is uncontrolled growth or unexpected changes that arise when a project is already underway. Scope creep is dangerous because it affects the outline of the entire project. Last minute changes and revisions can blow budget and time constraints out of the water. To prevent scope creep, go for a Minimum Viable Product and then revise accordingly from there.
4. Developer Capability.
A lot of times we hear from companies that start with an independent developer who may be cheaper, but then gets tied up in too many projects and can’t handle the amount of work and get deliverables on time. Or for an IT job, a smaller company might not have the resources needed for ongoing support or ramping up something quickly, especially when working with larger organizations. On the flipside, overkill is also a real problem that some businesses find themselves susceptible to. An example would be hiring a huge company that assigns too many resources to finish the job. In the end, this adds a significant amount of cost and time to the project, because of the increased amount of communication needed between staff.Why is this important? You want to find the “sweet spot” in terms of the company you choose to work with, one who can produce results relative to the size of your project. Going too big or too small can affect your bottom line.
5. Using an Old School Approach.
This is also known as “waterfall development”, or writing a ton of specs for a project before you perform the development. It is an outdated method of development…“Think this thing through in our head, and then start building 6 months down the road.”
The new preferred method is an approach known as Agile. With Agile, development is more like…“Let’s have a quick discovery meeting and then start building something immediately. This way we can show our customers what we’re making, get feedback, and circle back to make necessary changes.”
Using this new approach, you get constant feedback from customers, which helps avoid the next reason why software projects fail—the vacuum effect.
6. Building in a Vacuum.
Developers and IT companies have a tendency to build everything the way they think a customer is going to need it. When they bring it to the customer, the customer turns around and tells them the features aren’t what they were looking for. Avoiding this problem is a simple matter of testing and getting feedback, using something like the Agile approach above. This brings us to our final point…
7. Not enough communication.
Failure can occur when your developers aren’t talking to your subject matter experts or the end user, to figure out their needs. It’s very important to have a prototype group you can bounce ideas off of throughout the entire development of the project. This way you can get quick feedback about features and changes before the project’s first iteration is complete. In essence, you’re setting up a “feedback loop” that constantly ties the end user needs to the developer’s approach.
The Bottom Line…
There are many reasons why software projects fail. Preventing them and ensuring a successful project is a matter of having realistic expectations of your needs, finding the right sized company to work with and getting feedback from your customers to better suit their needs with your product.
Tom Swip has been developing and streamlining business processes for over 20 years. Tom’s expertise lies in business process automation, software and application design and network infrastructure. In his spare time, Tom likes kayaking, mountain biking and other outdoor activities.