For unknown reason, there is a common conviction that testing in the software creation process is not a significant element of the project. Sadly, such approach can cause a company to incur much higher costs than initially planned. Why? Because it is a sort of a ticking time bomb. It turns out that in the end software contains errors fixing which extends the time of the release of the product, namely, the above-mentioned software.
Such approach to a project is very costly not only for the company which manufactures the product, but also for developers, testers, and managers. It entails extended working time for the developer, longer testing, and a higher number of meetings held by the manager. We, therefore, create a situation in which we cause ourselves to incur much higher costs, when it was supposed to be the other way round.
Let’s take a project delivered in an incremental mode as an example. The client receives software updates which contain added functionalities. A growing number of projects at TTPSC are carried out in Agile methodology, which forces the processes to be complemented by writing automatic tests and reducing the time needed for running them. This is why we assume tha:
- The newly delivered functionality should work without problems according to the specification provided by the client;
- The newly delivered functionalities should not cause regression in the already existing functionalities.
Two critical points and in both cases the role of the tester is crucial..
First of all, it must be stressed that in order to save, the costs of testing must be taken into account. Companies which saved on testing were forced to spend much higher quantities on correcting the errors and mitigating the delay in the product release. This is why I dare to state that money spent on a tester is recovered.
The smoothness of the project, ongoing error detection. In fact, the tester should be involved in the project right from the very beginning. At this point, one question is often asked: “What is he supposed to be doing now? Waste of money! Nothing has been written yet so there is nothing to test”. Nothing could be further from the truth! The role of testers does not consist in performing tests only when the system is functioning. Their task is to understand the project, product, and client’s needs. Thanks to that, they are able to understand how every functionality is supposed to be working and what tasks and orders the system should perform. This is why testers should take active part in projects already at the stage of software creation. They should participate in project meetings with developers and technical leaders. Thanks to this knowledge, it is much easier for them to search for bugs and be one hundred percent sure that something really is a bug.
If we want to shorten the time needed for the preparation of tests, it is advisable for the tester to start writing tests at the same time as the software is being created. This is, of course, no simple task! Writing tests based exclusively on the provided documentation requires extensive experience. It may happen that the documentation received by the testers is not sufficient to create good tests. In such cases, the tester must also demonstrate communicative skills in dealing with developers, project manager, or the client that has ordered the product.
It is also important to be prepared to run the tests right after the functionality has been implemented. The role of the tester it to draw attention to the software’s logical errors or functions that are mutually exclusive.
It is true that the sooner such situations are detected, the less time we spend on making corrections. Ready systems require considerably more time and work, as their complexity level is significantly more difficult to fix and, consequently, more expensive, but I already mentioned that in the beginning of this article.
Therefore, the basis of maintaining a budget consists not only good planning, but also understanding of the problem, and communication among all the parties taking active part in the project, i.e. developers, testers, documentation keepers, managers, and scrum masters.