All articles

How To Turnaround A Failing Software Project

save failing software project

Wondering how to turnaround a failing software project?

You have found the right place.

There are huge sums of money to be gained by launching a successful software project, you need to get it right. Here’re a few amazing case studies of companies who hired DevTeam.Space to build their software products:

  1. DentaMatch – Healthcare Android and iOS App
  2. South Florals – Floral eCommerce Web Application
  3. ModuleTrade – Healthcare Android and iOS App

Introduction

Naturally, all product owners and developers hope to succeed with their software development project, however, sometimes things go wrong.

When this happens, you need to take decisive action to turnaround your  project. When DevTeam.Space recently successfully turnaround one such stalled project, the software development project to develop DentaMatch, we noticed that this requires distinct competencies that some might overlook.

As an entrepreneur or an enterprise software development project leader, are you trying to turnaround a failing project? If so, then you need to know about these competencies. This guide will show you how to turnaround a failing software project.

Contents

Failing software projects: How big is the issue?
1. Assess what went wrong with the project
2. Analyze the root causes of the project challenges
3. Determine whether you have a capable team
4. Check whether you need to replace any developer
5. Ascertain whether the project team has enough developers
6. Plan to turnaround the failing project
7. Execute the turnaround plan and track its progress
How about preventing your project from failing?>

Failing software projects: How big is the issue?

why software projects fail

A 2017 PMI report states that 14% of IT projects fail. Even among the projects that are not considered outright failures, 31% don’t meet their objectives, while 43% of projects see a budget overrun. Read “Pulse of the profession 2017 | PMI” for more information.

Several reasons might cause an IT project to fail, and the key ones are as follows:

  • Inaccurate requirements;
  • Insufficient involvement of the project sponsors;
  • Frequently changing project objectives;
  • Wrong estimates;
  • Risks that no one could foresee;
  • Delays caused by dependencies;
  • Under-staffed project teams;
  • Ineffective project management;
  • Delays caused by the project team.

Read more about these reasons in “The top 9 reasons for IT project failure: Is your project at risk?”.

I will now explain the steps you need to take to turnaround a failing software project, and these are as follows:

1. Assess what went wrong with the project

You need to assess what went wrong with the software project, and this requires you to take a deep dive. The project might already be in the news in your organization due to schedule slippages, budget overruns, or the quality management reports showing too many reds. However, these are manifestations of deeper issues.

Your deep dive must focus on what went wrong structurally or systematically, which caused the above-mentioned slippages or overruns. You ought to study several documents, e.g.:

  • The project requirements;
  • The IT architectural decisions;
  • The technical solution and the lower-level design documents
  • Test plans, test cases, and test results;
  • Review records;
  • Risks and issues logs.

You need to have several face-to-face meetings with multiple project stakeholders, e.g., sponsors, developers, testers, etc. Read more about this assessment in “Rescuing projects in crisis: Project turnaround pointers”.

2. Analyze the root causes of the project challenges

Having assessed the extent of damage to your project, you should now analyze the root causes. You need to focus on empirical evidence and data over hypotheses and guesses.

Read “4 steps to turning around a troubled project” for more guidance on analyzing troubled projects. A “Root Cause Analysis” (RCA) exercise involves going deep into the causes of failure, unearthing deeper reasons as you analyze.

The root causes typically belong to any of the following categories:

  • The lack of project management competencies;
  • Using an unsuitable SDLC model;
  • The development team lacking the required capabilities;
  • Choosing the wrong IT architecture pattern;
  • Ineffective use of cloud services;
  • Using unsuitable technology stack, development tools, and testing tools;
  • The lack of collaboration impeding the productivity of the team;
  • Measuring the wrong metrics.

We at DevTeam.Space are well-equipped for analyzing why software projects fail, and you can judge our capabilities in “10 biggest challenges when developing an app”.

3. Determine whether you have a capable team

You have just assessed what went wrong with the project. In some circumstances, the existing team might be able to resolve these issues, however, there are exceptions.

You need to meet the existing team and communicate the challenges facing the project. Honestly communicate with them about where you hold them responsible for the issues, and why.

You will need to change the existing team if you see any of the following:

  • The existing team doesn’t take accountability for the project issues.
  • It communicates reasons why it shouldn’t be held accountable, however, the reasons don’t quite add up.
  • The team understands their drawbacks, however, they’re at a loss about how to turn things around.

If you had hired a software development company for this project and it performed sub-optimally, then you ought to change the development partner. Read our guide “How to change your software development company mid-project” for more insights.

4. Check whether you need to replace any developer

You could also have a situation where the larger development team is capable, however, one or more developers aren’t. In such a circumstance, you need to have an honest discussion with the under-performing developers.

You might find that the said developers might have performed below-par due to specific reasons, and their performance would improve if you address the underlying reasons. At other times, you could find they aren’t capable of improving their performance.

In such a situation, you would need to replace the ineffective developers. Our guide “Getting rid of bad developers during a project” can help you to find a replacement developer.

5. Ascertain whether the project team has enough developers

At times, projects fail due to wrongly estimating the development manpower. While the team is perfectly capable, they might be under-staffed.

In such cases, you should hire competent developers to address the lack of manpower. As I have explained in “How to find a good software developer”, consider the following when hiring developers:

  • You need programmers with strong professional ethics.
  • Developers you hire need to have decision-making capabilities.
  • You need developers with sufficient knowledge of computer science fundamentals.
  • Programmers you hire should have the skills that are hot in the market, e.g., Node.js for web development, Kotlin for native Android development, Swift for native iOS development, Python for AI/ML programming, etc.
  • You need to hire developers with good knowledge of SDLC.
  • Developers need to know enough about proactively mitigating application security risks.
  • They should be able to code in a way that aligns with your choice of architecture pattern.
  • You need developers that know how to code scalable apps and have familiarity with managed cloud services.
  • They need to know the market-leading development tools, moreover, they should have industry knowledge.
  • You also need developers that can collaborate.

DevTeam.Space’s blog recently featured and article to help you to hire such developers. For more on this read “7 essential tips for hiring the best developers for your project”.

6. Plan to turnaround the failing project

By now, you have assessed what went wrong and ascertained the root causes. You have also dealt with under-performing team/developers and/or bandwidth issues in the team. It’s now time to plan the recovery of the troubled software project.

The recovery plan might include several tracks of actions and the “Root Cause Analysis” (RCA) determines them. We at DevTeam.Space have the right expertise for such recovery planning, as I had explained in “What is the best development approach to guarantee the success of your app?”.

You might need to address one or more of the following aspects:

6a. SDLC model

Ensure that you are using the right SDLC model for the kind of project you have. E.g., if you are developing a “System of Engagement” (SoE) like a mobile app, then Agile is better than Waterfall, as I have explained in “Waterfall vs Agile: which methodology is right for your project”.

You should also use the right approach that works with your chosen SDLC model, e.g., develop your “Minimum Viable Product” (MVP) in the right way in an Agile project. Our guide “5 tips to create a sleek MVP” can help you with this.

6b. IT architecture

Choose an architecture pattern that suits your functional and non-functional requirements and delivers the best user experience. There are several popular architecture patterns, e.g.:

  • Layered (n-tier);
  • Event-driven;
  • Microkernel;
  • Microservices;
  • Space-based.

You can use our guide “Large enterprise Java projects architecture” to make the right choice.

6c. Mitigating the application security risks

You ought to proactively mitigate the application security risks since this is crucial for the long-term success of your project. The key application security risks are as follows:

  • Injection;
  • Broken authentication;
  • Sensitive data exposure;
  • XML external entities (XXE);
  • Broken access control;
  • Security misconfiguration;
  • Cross-site scripting (XSS);
  • Insecure deserialization;
  • Using components with known vulnerabilities;
  • Insufficient logging/monitoring.

Read the “Open Web Application Security Project (OWASP) top 10 application security risks – 2017” report for insights on mitigating these risks.

6d. “Managed Cloud Services” (MCS)

Plan to utilize managed cloud services (MCS) smartly so that you can focus on development instead of IT infrastructure management. If you are developing a web app, then you should use a Platform-as-a-Service (PaaS) platform since it offers many benefits, e.g.:

  • PaaS platforms like AWS Elastic Beanstalk manage the cloud infrastructure, networking, operating system (OS), middleware, and runtime environment. You can concentrate on coding.
  • You can easily integrate databases and APIs when using a PaaS platform.
  • Reputed PaaS platforms offer robust DevOps tools and auto-scaling solutions.

Read our guide “10 top PaaS providers for 2020” for more insights.

On the other hand, if you are developing a mobile app, then use a Mobile-Backend-as-a-Service (MBaaS) platform like AWS Amplify. The following advantages make it a smart move:

  • MBaaS providers manage the cloud infrastructure and persistent storage, therefore, you don’t need to develop and manage the mobile backend.
  • You will be able to scale your mobile app easily, moreover, you will find it easy to implement features like user management and push notifications.
  • MBaaS platforms enable you to integrate APIs easily.

I have explained their advantages in “How to choose the best Mobile Backend as a Service (MBaaS)?”.

6e. Designing APIs

You will likely design APIs as part of your project, and you should keep the long-term success of your app in mind while doing so. While you might consider RESTful APIs, I recommend that you use GraphQL instead of REST (Representational State Transfer).

With RESTful APIs, you call an API endpoint to receive all data in it. On the other hand, GraphQL is a query language, therefore, you can specify the exact data elements you need. This has several advantages, e.g.:

  • With REST, if you need more data than what the API endpoint contains, then you need to make more API calls. This is called “under-fetching”. You can avoid this with GraphQL since you can query the exact data elements you need.
  • On the other hand, if you need less data than what the RESTful API endpoint has, then you receive unnecessary data. This is called “over-fetching” and you can avoid it with the query capabilities of GraphQL.
  • When using REST, you would design the API endpoint in line with the front-end view. If you change the view, then you would also need to modify the API. This slows down the front-end iterations, however, you can avoid this with the query capabilities of GraphQL.

Read “REST vs. GraphQL” for more insights.

6f. Choosing the right technology stack

Choosing the right technology stack improves your chances of turning a troubled project around. The choice of technology stack will depend on the kind of project, e.g.:

  • js will be a better bet for a web development project.
  • If you are developing mobile apps, then you might want to create native apps since they deliver the best user experience. You should then use Kotlin for native Android development and Swift for native iOS development.
  • PostgreSQL is a robust “Relational Database Management System” (RDBMS), whereas MongoDB is a popular option for NoSQL databases.

We at DevTeam.Space have the right expertise for choosing the appropriate technology stack, as I have explained in “How to create a minimum viable product for your enterprise company”.

7. Execute the turnaround plan and track its progress

Now that you have come up with a pragmatic plan to turn the troubled project around, it’s time for execution. Use the appropriate PM techniques and tools to manage the execution.

We at DevTeam.Space have AI-powered Agile processes, which are highly suited to turn troubled projects around. Our data-driven real-time dashboard helps clients to track the progress of the project, as I have explained in “How a real-time dashboard can revolutionize your eSports development process?”.

How about preventing your project from failing?

This article was focused on helping you to turn around troubled projects. However, it is always better to prevent projects from failing in the first place.

The key to this is choosing a trustworthy and competent software development company for your projects. Our guide “How to find the best software development company?” can help you with this.

Best of luck with your project.

DevTeam.Space is a vetted community of expert dev teams supported by an AI-powered agile process.

Companies like Samsung, Airbus, NEC, and startups rely on us to build great online products. We can help you too, by helping you to hire and effortlessly manage expert developers.

LinkedIn Facebook Twitter Facebook Messenger Whatsapp Skype Telegram