In this article, we’ll consider the main advantages of implementing QA at the early stages of the software development life cycle.
The efficiency of testing as well as the possibility to reduce the overall project time and costs largely depend on how accurately you formulate the requirements to the final software product. In other words, it’s possible to save money only if a customer knows what exact product he wants to get. Thus, the final result depends not only on the software development company but a customer as well. To achieve the best results, a customer should make a preliminary analysis to define the functionality that should be implemented in the final product.
Besides that requirements and preferences of the target audience should also be taken into account. If you hire a custom software development company, during the whole project life cycle, you should be ready to cooperate with the developer. In another case, a customer will be able to provide requirements only after the significant amount of time when the first result of development will be ready. Such situation can lead to additional efforts associated with the need for revision of the existing requirements. Furthermore, providing a development team with the ambiguous requirements, you will reduce the efficiency of early software testing implementation.
How Early Software Testing Implementation Affects the Costs of Software Development
So, why it’s so important to test a software product in the early stages of the project development? The developer should test the product during the whole period of work on the project, but the later you find a bug, the higher will be the cost of its fixing. Even significant changes made in the early stages of the project won’t lead to considerable budget changes. It’s much cheaper to change the product at the very beginning of the development lifecycle than at the final stages of the project.
Calculations show that changes made before the source code is finished on average cost 100 times cheaper than those that were made after the coding phase. The efficiency of changes made at the early stages is ten times higher.
Thus, it’s much more profitable to involve the QA team to work on the project as early as possible, for example, at the requirements gathering stage.
Below you can find some statistical and research data that describe in more detail how the project costs can change, depending on when you start testing.
Errors Not Found in the Early Stages Significantly Increase the Costs
Let’s start with the specifics of testing a software product. When you consider the project’s life cycle, it may seem pretty reasonable to begin the testing process at the end of the development process. Such approach can simplify planning, but potential risks in such case will be pretty high. In the worst case scenario, you’ll face the increase in the project budget, and the final product release will be significantly delayed. For example, an error can be detected at the stage of acceptance testing, one of the last steps of the software development life cycle. In this case, developers will have to change the requirements that already exist, rewrite the source code, and make additional tests to make sure that the error was fixed properly. All these actions involve additional costs that can’t be avoided since the fixing of the detected bug will cost you four times less than the elimination of its consequences in the operating software.
The Amount of Additional Costs Caused by the Errors That Aren’t Detected on Time
In order to avoid the scenario described above, it’s necessary to take a new look at the existing approaches to the development process. Many companies implement the methodologies that imply testing for critical software errors at every stage of the project life cycle, starting from the phase of requirements gathering. The main principle for most of the modern software development methodologies is a special attention to QA at each stage of the project. It helps to reduce the possibility of errors in the later phases, which is important because their fixing will be much more expensive. According to the data gathered by the Hewlett Packard company, the cost of correcting a bug detected at the last stage of the project life cycle (deployment and maintenance) is 30-100 higher than the cost of the same bug detected at the first stage:
As you can see, implementing QA at the early stages, such as requirements gathering phase, can significantly reduce potential development costs.
The Influence of Error Detection Time on the Final Cost of a Product: Research Data
Let’s take a look at the report “The Economic Impacts of Inadequate Infrastructure for Software Testing” which you can find at the National Institute of Standards and Technology website. According to the research, the procedure of detecting and fixing bugs during the development process can cost more than a half of the overall project budget. Depending on the accounting methods that you use, 30 to 90 percent of labor can be expended to produce a working program (Beizer, 1990). Early bug detection can significantly reduce the costs. Software defects can be classified according to the stage at which or when they were detected. Depending on the chosen development methodology, the project may consist of different stages, but in most cases, the main of them are: requirements, design, coding, unit testing, integration testing, system testing, installation or acceptance testing, and operation and maintenance. The longer a bug stays undetected, the more expensive it is to fix it. In the table below you can find the results of two independent pieces of research that reflect how the cost of bug correction changes according to the particular stage of the project. For example, it’ll cost 90 times more to fix the bug that was detected at the stage of system testing in comparison with the requirements gathering stage (Baziuk, 1995):
Specificity of software development does not allow to detect all bugs at once during a particular stage of the software lifecycle. This problem was studied in detail (Vouk, 1992; Boris Beizer, Software system testing and quality assurance, 1984) and you can see the results of the research on the graph below. It displays a typical S-shaped error detection distribution curve, depending on a certain stage of the software development lifecycle:
This data illustrates one of the main problems related to the software development process: “Most software errors are found during the middle to later stages of development (namely integration through primary release), which happen to be the most expensive stages to fix errors” (Rivers and Vouk, 1998).
Let’s compare the data on the distribution of detected errors at various stages of the life cycle of the project with the growth of costs on bugs correction depending on the time of their detection. We’ll be able to predict the potential costs of development. This data can be presented in the form of a stepwise graph, an example of which is given below. The area under the graph is equal to the costs of bugs detected in different stages of the software life cycle. Thus, if we know the overall costs on testing throughout the software life cycle and further bug correction, we’ll be able to calculate the average cost of a particular bug depending on the stage at which it was found:
In practice, it might look like this. To correct a bug that was detected on the stage of requirements gathering you have to spend 100. If the same error is detected at the time you start testing, it will cost 1500. At the stage of production, the cost could be $10,000. In case this bug is never found, it’s pretty hard to predict the expenses for the company. Let’s consider some practical examples that illustrate how errors that weren’t detected at the early stages of a project led to unpredictable consequences.
In 1962 NASA launched the Mariner-1 spacecraft to Venus. Mariner-1, which was launched from Cape Canaveral, veered off course because of a software bug. A NASA range safety officer on the ground initiated a self-destruct command that destroyed the spacecraft 290 seconds after the launch. According to one of the reports, this accident was caused by the omission of a hyphen in the coded computer instructions or in some formula. As a result, Mariner-1 got wrong guidance signals. This error cost to NASA more than 18 million dollars.
In August 2012 Knight Capital Group, one of the biggest American trading companies sent over four million stock orders in less than an hour by mistake. These orders should have been sent over a couple of days, and the overall cost of trades was almost half a billion dollars. The company would have been faced the imminent bankruptcy, but a group of investors came up with 400$ million and saved the firm. The whole situation was caused by the server update error. Code update was not deployed to all the servers. The one that was missed used old instructions and sent all these orders. The shares of the company lost 75 percent after two days. This software error led to losses in the amount of 440$ million. You can check this link to find more examples of how the underestimation of QA can affect the overall project budget.
The cost to fix an error directly depends on what stage of software development life cycle it has been detected. Any found error may cause a domino effect. The initial approach should be reviewed to adapt to the necessity of changes which, in turn, can delay already scheduled changes to the source code. Thus, the detected bug leads to additional delays and expenses. And what’s more important, the later you find an error, the more resources you’ll have to spend to fix it. An error that hasn’t been found on time may require 100 times more efforts on its fixing after it gets to the stage of software deployment. Thus, to stay within the planned budget, it’s highly recommended to involve the team of testers at the stage of requirements gathering. But you have to remember that without the interaction between the customer and the developer, the efficiency of early QA input may not be so high. The reason is that clearly and unequivocally formulated requirements for the final product are critical in this situation. If you want to be sure that the software you use is bug-free but can’t afford to test it using your resources, you should pay attention to software testing outsourcing services provided by the development companies.
Reduce your costs with XB Software top-notch QA staff augmentation services. A dedicated web development and QA team of XB Software can take care of your project.
Latest posts by Alexandr Rayskiy (see all)
- Why Should Testing Start Early in Software Project Development? - October 23, 2017
- The Cost of Bugs: Why You Can’t Ignore Software Testing - April 22, 2016
- The Cost of Software Testing, or What The Client Pays For - August 3, 2015