Why Do Software Projects Fail?

Why Do Software Projects Fail?


4 min read

For many companies, delivering software solutions is either the primary way to generate money or a tool to increase revenue.

However, while many software projects succeed, many others fail.

According to a Standish Group report, 66% of software projects fail.

But...why do they fail?

Here are some possible reasons:

Poor Requirements Engineering

In software engineering, capturing requirements is the step that leads to designing a system.

Requirements engineering allows software engineers to start designing the system.

When this step doesn't align with what the end users want, we create a project that doesn't align with the user's needs and expectations.

Related: What Is A "Requirement” in Software Engineering?

Rush To Build Software

More often than not, software engineers work in environments that encourage delivering pieces of software at a fast pace.

On many occasions, going fast means cutting corners and firefighting.

Usually, Unit Testing is the one step in the software development process to be cut out to deliver a project as fast as possible.

There are many reasons a software project is created and delivered in a rush (one reason could be a poor use of the Agile framework).

Either way, this may contribute to the failure of a software project in the long run.

Related: Brief Introduction to Scrum

Poor Testing

As mentioned in the paragraph above, testing is the first step to be left out when software engineers are under pressure to deliver a project.

A lack of or poor testing means delivering software that may contain glitches, bugs, security breaches, etc.

Addressing poor testing becomes even more time-consuming if the software has already been delivered, especially if the pressure to provide new features is never-ending.

Related: 3 Types of Software Testing for Developers

Unrealistic Expectations

Users often don't understand the complexity of software engineering, and they tend to oversimplify the complexity and uncertainty software engineers have to deal with.

This leads to projects being requested to deliver as soon as possible, putting unrealistic expectations on software engineers.


"Scope creep" (which happens when a project becomes more complicated over time compared to what was initially expected) is real in software engineering, and estimating the complexity of a project upfront is a challenging task.

Lack Of Documentation

Software engineers and other members of the software development lifecycle often underrate documentation.

A lack of documentation means:

  1. Not having an agreed set of standards.

  2. Not having a vision of the software's architecture and what it's meant to achieve.

  3. An overall lack of clarity.

Related: Why We Need Architectural Design In Software Engineering

Examples of Software Projects That Failed

London Ambulance System

In 1992, the London Ambulance System introduced a computerised system to manage the allocation and dispatch of patients.

There was a first attempt when the project received an investment worth millions of pounds.

Following the first attempt, there was a second attempt where the software was crushed a few days after the release.

The project failed because:

  • The software development team wasn't involved in the requirements-gathering process.

  • There was poor communication between management and staff.

  • No early feedback was taken from the project users (ambulance operators, dispatches, etc.).

  • Inexperienced people built the critical components of the system.

  • The interface was poor.

  • There was poor testing.

Computerised Ministerial "Red Boxes" 1999

This project aimed to design an electronic version of the "red boxes" used to store and carry official documents.

The box used fingerprint technology to ensure only the minister it was indented for could open it, and information was to be transferred through a secure government intranet.

The project failed because:

  • The software was too complicated.

  • The end-users were unable to understand the system.

  • There was resistance to change.


Now you know why many software projects fail.

Have you ever worked on a project that failed? What was the main reason? Let me know in the comments!

Until next time!


P.S.: if you enjoyed this article, you'll definitely benefit from subscribing to my FREE weekly newsletter, where I share curious insights around career development, software engineering, and more. I hope to see you there!

Did you find this article valuable?

Support Maddy by becoming a sponsor. Any amount is appreciated!