Testers and developers are two mandatory components in any software development process, and although some might argue that you can develop a piece of software without involving testers, in order to be a competitive software company you need to have a testing department. While a developer is seen as the creator of the application, the tester is perceived as the “breaker“, the one who’s job is to break the work of the developer. (Sounds familiar?!)
However, this perception is flawed, as the two jobs are complementary and not in opposition: the developer builds the software application from scratch, while the tester enhances the developers’ creation even if this means breaking it first.
More often than not, developers feel that testers are the opponents who underline the flaws in their work. Due to this perception, sometimes, communication between testers and developers is not very efficient, resulting in communication gaps and loss of quality. So poor communication between the two sides (testers and developers) affects the entire team and also the end result.
Although developers are the main actors in the software development process, testers are the ones without which the implementation wouldn’t be complete. It takes expertise and creativity to build an application, but it takes a lot of skill to identify issues and help shape the software product. Also, even if the work of a developer can be immediately translated into profits, once the product reaches its target, the work of a tester is embedded in the final product and assures the customers’ satisfaction.
What makes a good tester / developer great?
In order to grow into a good tester, one has to learn testing methods that will allow him to test most areas of the product and to find all major issues during the development process. A great tester is the one who’s able to communicate with the developer and help him shape the product in such a way that both an average and a professional user will be satisfied by the end result. For example, software usability issues can be prevented if the tester collaborates with the developer when creating the initial design of the app.
On the other hand, a great developer is the one who tests his code before handing it over to the testing department, but also involves the tester in the development process and takes into consideration the tester’s input before implementing a new feature (often this proves to be a great asset). This way, valuable development time can be saved (and costs lowered), thanks to the fact that more bugs have been avoided.
After all, everybody knows that a software with fewer bugs is a more stable & successful product, and this in the end determines the degree of customer satisfaction.
For a software development company it’s highly important to reach the correct testers-to-developers ratio, because this way the number of loopholes will be reduced and many bugs will be prevented, and so the end product will become more stable.
Testers vs. developers ratio
But what is the correct ratio of testers vs. developers? While this varies greatly from one software company to another, and the type of software product that is being developed, the most common ratio is: 1 tester for every 3 developers.
An exception to the rule can be considered to be the small projects (involving 4-5 developers), where the developers can also be the testers. In reality this is a bad scenario, because developers will be (most of the time) subjective when testing their work, and also this is not very cost-effective, as development time is more costly than testing time.
However, experience has shown that it’s best that the project manager / test manager decides the most suitable tester – developer ratio, after taking into account a series of factors, such as:
* The range of configurations that need to be tested
* The testability of the product
* The available tools
* The experience of both testers and developers
* The quality standards that must be met
* The complexity of the product
* The cost of a missed bug (this depends of the stage of the product’s life cycle; a missed bug can be ten times more expensive if discovered towards the end of the software product’s lifecycle)
The 2 Cs: Collaboration and Communication
Overall, there are still mixed feelings when it comes to the testers vs. developers relationship: if some software companies have specific policies regarding the interaction between the two, others leave it to be settled on its own. In terms of software development & testing methodologies, some companies prefer the traditional approach for developing software (Waterfall model – a precise planning of the development process; usually testing is performed after the development has been finalized), while many have adhered to the principles of the Agile development (which values interaction between testers and developers and promotes the involvement of testers in the development process, among other things).
No matter the chosen approach, one thing is generally acknowledged: in order to reach customer satisfaction and a quality software product, all differences must be put aside, and developers must learn to collaborate and communicate with testers (and vice-versa of course :).