There is an ongoing debate around organizing testers and testing. Our plan is to summarize it for you. The first half of this article will be about testing and the second about testers.

Essentially, there are 3 different types of testing:

  • Inside the project, within the development team.
  • As an independent team providing services to the project.
  • A mix of the two. 

The Advantages of Testing

Here’s how you’ll benefit from all three types of testing. On the one hand, in-house test teams took part in the project from the early stages and are well-versed in all aspects of it.

On the other hand, an independent test team doesn’t report to managers about anything besides finding bugs or assessing quality. They provide an unbiased assessment and spot what programmers missed.

What we recommend is a mix of the two.

Get an independent test team and integrate it into your project from the very beginning. This way, the independent team will be able to handle higher-level phases of testing in a way that complements unit and component testing.

Also, suppose you have multiple projects that require testing simultaneously. In that case, we recommend assigning them to the same independent team. You can find more on this topic in the ninth chapter of Rex Black’s Managing the Testing Process.

Structural, Behavioral, and Live Testing

For optimal bug detection and removal, a project needs all three.

Structural testing is based on programming and other technical skills. Behavioral testing often requires specialized testing and application domain skills. Two examples of testing skills are security and performance testing, skills the average programmer doesn’t possess.  

Regarding application domain skills, Rex Black gives this example of one of his clients who writes geological modeling software for oil exploration. To test the functionality and workflows, one must be a geologist, geophysicist, or similarly skilled professional, not a programmer.

We’ve seen that projects go more smoothly when programmers do some unit and component testing of their own code. Doing this requires both structural testing skills and programming skills. 

Code Swapping

It’s common that many programmers have trouble testing their own code. A good practice to adopt is a development process divided into two parts. One for unit testing, where programmers find bugs in their own software, and one for component testing, where programmers test each other’s software. This is called “code swapping.”

Also, because behavioral testing requires special skills, it makes sense to group the people in charge of it, here’s why:

1. It provides group synergy. Testers can review each other’s test cases, test results, and bug reports.

2. It can raise morale, which is vital for testing because it often involves delivering bad news.

3. It provides opportunities for specialization, skills growth, and career paths beyond just moving up into a programming position. This boosts test team performance and credibility.

Additionally, a test team in charge of multiple projects at once offers even more opportunities for specialization and growth. Their highly skilled professionals are to blame.

Good management

There is one more essential factor to a good organization: a competent, seasoned test team manager. This person serves as a technical leader of the team as well as a manager. This combination works very well with testing projects, here’s why:

  • They identify dependencies and manage changes in them.
  • They bring significant people management skills, especially in hiring and growing the test team.
  • They advocate for their team and relay the team’s contributions and findings.

The latter is essential. An independent test team must report findings, good and bad, in an unbiased manner. Fortunately, by being a third party, there is no need to sugar-coat the situation. The client can be sure to get a fair assessment of your project.


Some people advocate for no test team whatsoever, just testers working alongside programmers within development teams. They think that it will lead to better integration, therefore to better results (a.k.a finding more bugs).

We also agree that integrating an independent test team since the early stages of development is crucial.  However, we don’t believe that testers who report to development managers will outperform testers reporting to independent test managers when measured on test effectiveness and efficiency. That is not the case.

Test positions within development and maintenance teams are often considered junior roles.

Testing provides value mainly through delivering information. Consequently, testing adds value only when people listen to test professionals. Clearly, you’re more likely to listen to people who have more credibility.

It also has at least two negative implications for the testing process:

1. Competence – people assigned testing roles are likely to have good technical skills but poor (if any) skills in the application domain and testing itself.

2. Career paths – temporary testers will focus on increasing skills in technology and application, but few will develop their skills in testing.

If you need further convincing on that, read the first chapter of Rex Black’s Critical Testing Processes: Plan, Prepare, Perform, Perfect.

You can also book a meeting with our seasoned manager to discuss more about organizing testers and testing: