This is part 1 of the 3-part “Failure Series” of blogs, where we will take a deep dive into common issues that organizations face when implementing new systems and solutions. The goal is to gain an understanding of why implementations fail, the costs that are associated with failure, and ways to avoid failure altogether. Let’s start with taking a look at why implementations fail.
Failure is something that all people and organizations face at one point or another. It often necessitates learning or growth and enlightens a clearer path to success. That does not mean that failure should be viewed as acceptable. In fact, it should be avoided at all costs, especially when it involves core systems and new implementations.
A recent study by the Standish Group revealed that only 14% of IT projects are purely successful, meaning they are delivered on time, on budget, and with high customer satisfaction and high return on value for the organization. Conversely, 19% of IT projects are utter failures.
There are numerous reasons why implementations fail, and they can vary depending on the uniqueness of an organization, the specific industry it operates in, or just a basic misunderstanding of expectation versus reality. Regardless of the variables, failure can usually be traced back to 3 core reasons: understanding data, required resources, and third party implementation partners. Let’s take a closer look at all 3.
1. Understanding data:
Do I understand my data and is it readily compatible with the new solution?
Organizations are quick to pull the trigger on purchasing solutions without understanding the necessary nuances around their data. Where does it come from? When is it collected? How is it stored? What structure is it in? Are there integration requirements?
These are key elements that need to be known before implementation can begin and should be part of advanced planning that takes place during the browsing or buying process. Unfortunately, they often get overlooked and when organizations are ready to begin implementing a new solution they purchased, they are abruptly met with issues that stem from the data.
Most commonly, data sources are incompatible with the new solution, the data format doesn’t match the required structure to flow into the new solution, and the many known and/or unknown data feeds prove difficult to reconcile with the new solution.
These and other similar issues delay or derail implementations completely. However, when you take the time to really understand what you have before you even begin looking for what you need, you can easily avoid them.
2. Required resources:
Are the right people available to ensure success?
There is always some degree of a learning curve when implementing a new system as users will need time to adjust to using it. To ensure that they keep timelines, hit deadlines, and continually build on their understanding and knowledge, it is important that these people are aware of their roles in the implementation and what will be required of them during the process.
Old roles do not necessarily translate to new functions. A person with the title of project manager may not have the aptitude to lead the implementation because they do not have the required skills or even time to dedicate. Prior to the kick-off of the implementation, the requirements of the project must be identified, and the right people must be evaluated and matched with their proper functions. When this does not happen, implementations stall.
People without proper knowledge or training get dropped and new people join the process, which results in uneven work and delays the project as the new people get acclimated. These disjointed efforts create gaps in completion or even cause oversights in key elements needed to properly test the solution. The more prevalent these are, the higher the risk of failure and abandonment of the project.
3. Third-party implementation partners:
Who does the implementation – me, my vendor, or a third party?
A key question that organizations often fail to ask when browsing for a new solution is “Who?” Who is going to be doing the implementation?
Some vendors partner with their buyers to do a collaborative implementation, while other vendors make the buyers do it 100% on their own. Conversely, there are also vendors that handle the implementation themselves for an additional cost. But in any scenario, there needs to be a firm understanding of whose responsibility it is.
What some vendors may not disclose is that when they handle implementations, they use third-party resources to do so. These third-party partners do not have the same knowledge of your organization. They are often not a part of the preliminary or planning talks and are simply assigned tasks. Therefore, they do not fully understand the challenges or issues your organization is looking to address with a new solution, and do not properly design the features of the software to align with your desired results.
As identified in #2 above, it is important to know who is involved in the project and what their role is. Managing an internal team is challenging enough but corralling additional people from a third party creates an unnecessary challenge. What we have seen from implementations that follow this path include collapses in communication, uncertainty around who is doing what, missed deadlines, and delayed delivery. This can cause friction, as faith in the project begins to falter and more problems arise than solutions. Many organizations walk away from failed implementations caused by third parties and wish they knew about them before purchasing.
It’s always exciting getting a shiny new toy, and sometimes we are so eager to have something that we don’t do the proper research ahead of time to make sure what we are buying is what we truly need. Understanding our own needs is crucial in ensuring that our expectations are met upon purchase. We should always do research, ask questions, and leave no stone unturned, especially when we are ready to make a large financial commitment that affects not only ourselves but the entirety of our organization. Understanding the reasons many implementations can fail will hopefully help avoid them in the future.
Stay tuned for the next article in this series where we will be looking at how a failed implementation can have serious costs associated with it, beyond just the bottom line.
In the meantime, here are a few examples of how organizations like yours successfully implemented no-code solutions and achieved outcomes beyond expectations.