• info@helpingtesters.com
  • helpingtesters

Testers are not required in the project! Is this true?

Testers are not required

Even though testers add quality to the application, we quite often hear this statement Testers are not required in our project. What are the different excuses usually given, as to why testers are not required in the project? Is it really true? Let’s see ahead in this article.

When a new project starts, the complete application has to undergo the complete software development lifecycle until it is pushed to production. And testing is an integral part of every software development cycle. Testing, in spite of being such an integral part, is often looked down upon and considered as a redundant practice.

In many projects, clients or senior members of the team provide a lot of importance to the core development practices while testing is left out. Why do experienced IT professionals even after being fully aware of the advantages of testing give up on testing? Why is it that even clients are ready to compromise on the quality of their project and not recruit testers? In the coming sections, we would read about the different excuses for not involving testers in a project. We would also evaluate the plausible reasons for such an action and what ideal steps can be taken to resolve this issue

Common excuses for stating testers are not required for the project

Some of the most common excuses given for stating that the testers are not required for the project are as follows:

  • The scope of the project is small
  • The project is quite small and has a few modules. The modules are quite straight-forward and can it’s without the need for any testing.
  • The complete project is divided among different project teams or organizations and the development process is quite simple.
  • Project deadline is way too close for involving testers
    • If a project needs to be rolled out in a week, there would be very little time to go through the requirements and let alone develop the application. For this reason, there would be less time available for testing. So it is better not to involve testers.
  • As for most fast-track projects, pushing a stable codebase to production is of utmost importance, any residing minor issue can be taken care of later on.
  • Involving testers in projects with short release cycles would slow down the development process and prevent the team from meeting project deadline.
  • All we can afford from the budget of the project is peanuts
    • When the project has a shoestring budget, the project management team has to devise a way to cut down on project costs. One way of doing so is by hiring employees judiciously.
  • As developers would be closely working on the development of the application’s front-end and back-end they would be allotted in the project. But the management team would think twice before appointing testers, especially when there is a scarcity of budget.
  • Our developers are capable enough to test the application themselves
    • This is one of the major reasons why testers are not a prerequisite for any project. Once developers are done with their development task, they can take up testing of the application.
  • To make testing a bit more effective they can interchange modules amongst different developers so that they can improve the quality of testing.
  • Apart from manual testing, if developers devote time to enhance their unit tests, they can even test the application without any manual intervention. Such a strategy helps the project management and the clients to get the most out of the resources.
  • The client doesn’t feel its required
    • Every project is rolled out in such a way that it strictly adheres to the requirements and desires of the client. If a client feels that the scope of the project doesn’t demand any testers, there is no way to involve testers in the project.
  • The client may even desire testing to be conducted at their end rather than at the development center, so its best to stick to what they demand.
  • The required testing skill is not available
    • The application modules were complex, which demanded different types of testing, namely API testing, automation testing and performance testing.
  • Also, to reduce downtime and manual intervention, the test scripts had to be scheduled using one or the other Continuous Integration tools. As the available testers only had expertise in manual testing and lacked technical expertise and coding ability, the team couldn’t take up testing.
  • During the testing phase, our developers would remain idle
    • As the project follows a Waterfall model, all development processes are sequential. So when the developers would be coding the application, the testers would remain idle.
  • On the other hand, during the testing phase, the engagement of the development team would be minimal as they would only be taking care of the defects and issues.
  • As resources from both teams won’t be utilized properly, it is best to keep testers out of the project and let developers lead the complete release.
  • It’s hard to recruit testers at short a notice
    • Even though the project demanded required testing, there was a shortage of testing resources.
  • Given the timeline and scope of the project, the recruitment team had very little time to recruit new testers who would be fit for the project. For this reason, it was communicated that testing would be out of scope for the current project, and the client needs to find other ways to complete testing.
  • Existing automation scripts from the previous release would be just fine
    • The current release items were based on an existing project which was already rigorously tested. The original codebase has already been moved to production and is being used by active users. In this release, the development team had to cater to small change requests requested by the client.
  • As the team already has a stable automation suite from the previous release, we can re-use it to test the complete application. The automation suite has numerous test cases which can help test the different modules of the application as well as execute integration and regression tests.
  • As there is no UI, there is nothing to test
    • For projects or application modules which primarily focus on different APIs, web services, and databases, need not rely on any user interface.
  • Such modules only accept requests and inputs from other interacting modules. For this reason, testers are not required as entities like databases and APIs are self-sustainable on their own.
  • Also, to test these components a bit of scripting and coding would be involved which might be out of the scope of most testers. And if demand arises, the unit test cases would be enough to test the endpoints of the application.

Decapitating the myth

All the above-mentioned points were the common excuses given by the project management or client for not onboarding testers. But, can a project’s quality be ensured by not incorporating testers at all? The answer is, ABSOLUTELY NOT!

Testers add quality

  • Even though a QA team is responsible for testing the application, their primary aim is to improve the quality of the application being developed.
  • Apart from testing the application against the requirements provided, they incorporate different strategies and testing techniques to ensure that the application doesn’t malfunction in the future when subjected to different actions from the users.
  • Right from executing simple & complex test cases, testers perform regression testing and even create automation scripts to test the application when testing resources are not physically present at the office.
  • Even when the testing scope is less and merely consists of a handful of change requests, testers should be involved in the project, even if it is for a brief moment or late in the development cycle.

You can involve testers even if the client said “Testers are not required”

  • The rule of thumb for any company is to abide by the requirements and requests put forward by the client. But that doesn’t mean you can’t put forward your suggestions.
  • Once the project starts and if the client tells testers are not required in the project due to some reason, the project management can involve a handful of shadow resources to test the application and generate a report which would enlist the number of bugs encountered and the different suggestions provided by the appointed testers in terms of functional and UI changes.
  • This report would clearly show the improvement in quality when testers were incorporated in the project. Such a quantitative report can help the clients realize the benefits of incorporating testers and might convince them to include testers in the project.

Testing is not always about the UI

  • Clients who are not adept at the technical aspects of the application might feel that for an application which lacks a UI, involving testers would be unnecessary.
  • But that is definitely not the case. Back-end applications or web services in spite of not having a user interface requires testing.
  • Apart from functional tests to check the requirements and behavior of the module, security testing can also be done.
  • Such testing can help identify loopholes in the application and also prevent malicious attacks from third-party entities.

In case of time crunch don’t compromise on testing, rather switch to a different development process

  • One of the prominent reasons for mentioning that testers are not required in projects is due to the short release span. So rather than investing time in getting the application tested by testers, the project lead/ manager encourages the development team to test the software themselves. That is neither a good practice.
  • Rather they should come up with a plan which would allow the testers to test the application without compromising the release date. And the best way to get the best of both worlds is by switching to a different development process.
  • Agile methodology is one way to achieve this. TDD (Test Driven Development), which is a flavor of Agile allows you to test the application properly without stretching the release date. By adopting TDD, the development of the modules would be steered by the test cases created by the testers.
  • So right from the designing phase, the test cases would drive the development and the development would progress only when the test cases pass. In this fashion, testing can be coupled with the core development without extending the release dates.

Testing expertise and know-how can be easily revamped

  • Any type of learning has a starting point. Testing is no different. For example, if a project wants experienced API testers or automation testers, while all the team has at their disposal is manual testers, the project manager shouldn’t say “no” to the client. Rather, they should set up training to help the existing team get a crash course in API or automation testing.
  • If getting tutors is not possible, they can even enlist the candidates in online e-courses which they can access from home and practice in their free time.
  • Getting a skilled output after such a course would be extremely difficult, but at least it will buy the management team some time to recruit more experienced testers to guide the existing batch. At the same time prevent the company from losing business.


  • Now, after discussing all the excuses given stating that the testers are not required for the project, we can definitely say that including testers in a project would improve the quality of the delivered software.
  • The project management team must talk with the client and take any steps necessary to ensure that proper testing is conducted before the product is rolled into production.
  • In the case of time-crunch, the development process must be molded to accommodate testing. The team must be flexible enough to embrace such a change and to make sure that the development and testing team act as one to add quality to the project.
  • To avoid stagnation, the project management team should conduct training and seminars from time to time so that the testing team is aware of the latest trends and practices in testing and are well aware of the basic core concepts of different testing methodologies.

Hence, Testers are not required in the project.

About the author

arindam bandyopadhyay author

Arindam Bandyopadhyay is an automation tester with over 5 years of experience in software testing. While during the day he juggles between Eclipse and spreadsheets, at night he lets his fingers do the talking as he writes about anything and everything his paradoxical mind desires.

Leave a Reply

Your email address will not be published.

Recent Posts