Before talking about a good software testing team, let’s define what is meant by a “good software tester”. Depending on who you ask, there are at least as many definitions of “good software tester” as there are testers, and any of them can be valid in someone’s circumstances.

Knowing what makes a good software tester can help testers to target specific areas to improve on. The knowledge can also help managers mentor and evaluate their testers, and craft better job ads to hire new testers. The specifics might vary from workplace to workplace, but the general principles don’t.

There are three main groupings that people use to define what makes someone a good tester. Those groupings are based on:

• Skills 
• Attributes
• Knowledge 

The Case For Skills

Skills are a large part of what lands in a tester’s toolbox. In part, this is because some of the skills a tester needs can be measured, sometimes called “hard skills”. Things a good software tester can do are often easier to describe than things a good tester knows or things a good tester should be.

The Hard Skills

Hard skills are generally things that can be measured, like programming ability with a particular language, ability with a specific tool, and so forth. There are a number of hard skills that fall into the kinds of skills a good software tester needs.  Some of the more common ones, and the underlying softer skills they may represent, include:

• SQL – A good tester will be querying a database used by any application they’re testing. Sometimes testers will also need to update and modify databases to prepare data.
• Programming – Programming knowledge is often demanded for automation positions. A basic understanding of programming and limitations is a good thing for any tester. 
• Writing test cases/test plans – This skill is in most cases a proxy for the ability to decide what needs to be tested and the ability to communicate test results in a format that’s easy for non-testers to understand. 
• Application lifecycle tooling – This can be in the form of a specific bug tracker or an all-in-everything application lifecycle management suite.

The Soft Skills

Soft skills get their name because they are clearly skills that need to be learned before they can be used effectively, but aren’t necessarily measurable. Some of the soft skills a good software tester needs are:

• Communication – Communication skills is a very broad collection covering formal and informal, written, verbal, peer-to-peer, to-supervisor, to-subordinate, and every other possible combination imaginable. A good tester needs to be able to decide how formally to communicate, who to communicate to, and what data to communicate. 
• Critical Thinking – Critical thinking skills is another broad collection covering analysis, deduction, problem solving, research, troubleshooting, and many more. For a tester, the skills in the critical thinking group are essential to deciding whether an anomaly is a problem, how much of a problem it might be, and what to do about said problem. 
• Leadership – Leadership skills for testers can include the typical set of “management” type skills for those of us in charge of a test team, but for most testers, the leadership skills used are things like leading by example and mentoring. 
• Teamwork – Teamwork skills usually include a lot of overlap with the communication, critical thinking, and leadership skill sets, especially when a tester is working closely with non-testers. 

The Problem With Attributes

Some of the more common attributes of good software testers include things like:

• Fast learner – A tester who isn’t a fast learner will be overwhelmed any time they move from one business domain to another, or have to adapt to a new technology.  
• Multi-tasker – Humans can’t truly focus on multiple things at the same time. What we can do is minimize the cost of task-switching, and that is something a good tester must be able to do.
• Detail oriented – A good tester has to be able to focus on the details to keep the little things from becoming big ugly bugs, without losing sight of the overall goal.

Knowledge Isn’t Everything

Knowledge, the third grouping of criteria used to decide what makes a good software tester, has the dubious distinction of being both easier and more complicated to determine. 

That said, there are certain types of knowledge that tend to be commonly expected of good testers:

• Domain knowledge – Knowledge of the nature of the business the software serves is a common requirement for testing positions. Testers are often most effective when they’re deeply familiar with the business (or other) domain they’re working in.
• Technical environment knowledge – In job ads the need for knowledge of the technical environment is usually stated as “familiar with x” where x can be anything from an operating system to an automation tool. 
• Assumed knowledge – In my experience, no matter where a tester works, there will be a certain amount of assumed knowledge. Typically testers will be expected to know how to type, how to use software like Microsoft Office and its equivalents, and generally speaking how to find their way around a computer.

Knowledgeable But…

Of course, knowledge alone isn’t as useful as it could be. It’s one thing to have read the books and know the information, but if you don’t know how to use what you know effectively, you’re not going to do as well as someone who does use their knowledge. In short, while knowledge can be helpful, if it’s not applied where it’s needed, it’s not going to be very useful.

Knowledge can also be subject to the old saying, “If all you have is a hammer, everything looks like a nail”. Without knowing how to properly apply knowledge, the results can be less than ideal.

When I Was A Wee Little Lass

Knowledge goes out of date, especially in a field as changeable as information technology. People’s knowledge tends to “freeze” at wherever it was when they last dealt with it in any depth, with the result that as time passes, what a person knows has a way of getting ever more outdated. The saying, “it’s not what you don’t know, it’s what you know that ain’t so” is one a good software tester will keep in mind.

As long as testers can adapt to the rapid changes in their field, and they’re continuing to learn and find ways to improve the skills, attributes, and knowledge in their tester toolbox, they’ll be good testers. They just have to find a place where their abilities are valued and their toolbox is a close enough match to the company needs that they will be able to fit in and grow without too much conflict.

Qualities that can make you a good tester

• Understand the objective of the software.
• Understand the inputs and outputs of the software.
• Master the tools to be used for testing the software.
• Know the deadlines and timelines for the testing assignment.
• Use a good method for collecting and reporting test results.
• Communicate well in time and well in mode.
• Have confidence in yourself and in your team.

A good software tester has a broad range of knowledge, experience, and skills, and is very skilled/knowledgeable in at least two of them. Good testers are able to adapt to new environments and become productive in a shorter time than average when faced with an unfamiliar environment or skill-set.

Good testers are typically self-starters: they will teach themselves new skills and practices to improve their tester toolbox, and will often try to help others to build on their abilities and skills.  They are also likely to seek out mentors within or outside their company to help them build new skill sets.