As software testers, we routinely make educated “guesses” about:

  • What bugs exist
  • Why they occur
  • How to fix them

This type of work adds tremendous value to the software development cycle.

But there exists another strain of guesswork – one that adds zero value. In fact, it often results in excessive lag times and escalating costs. We’re talking about needless uncertainty surrounding:

  • The appropriate tools to use
  • Project scopes, goals, and deliverables
  • Next action steps and responsibilities

Reducing these bottlenecks allows us to focus on more important things like creating high quality products that make our users happy.

But how do you minimize this additional guesswork? How do you leverage limited resources to deliver optimal impact in the marketplace?

Below is a breakdown of strategies teams can use to improve their own testing.

1. Adding Clarity to the Testing Process
One of the most essential steps in resolving uncertainty involves clearly defining purposes and processes. More specifically:

  • What are we testing (and why)?
  • How will we test these assumptions?
  • How and to whom are the results reported?

And maybe most important of all – what defines success? Without this metric clearly outlined, testing can easily become a never-ending cycle of fixes that deliver marginal returns (and consume ever-increasing resources).

2. Software Testing Should Be Efficient
Defining success offers another important benefit – the ability to redirect resources to wherever they’re needed most. By making optimal use of time and energy, you can minimize overhead.

In other words, we should test to improve the product – not to fulfill quotas. This way, you don’t need to beg, borrow, or steal additional bandwidth from other resources and team members.

3. Software Testing Should Never Become Routine
When done correctly, software testing is challenging and should consume your full attention. The moment it becomes repetitive or irrelevant, mistakes are inevitable – mistakes born of boredom, not inexperience.

One common workaround is to create scripts and/or automate that which is inherently boring. This strategy allows us to redirect our focus to non-redundant tasks that actually do require our full attention.

4. Testing Is Not an Addendum to Software Development
We’ve covered this topic before, but testers should be integrated into the project workflow from the very beginning. The value we provide isn’t an addendum or afterthought. This much is patently obvious when you realize that testing represents as much as 80% of total development costs.

Failure to include testers during the initial planning stages is one of the easiest ways to drive up those costs. Our input, when provided early on, can help reduce easily avoidable mistakes from creeping into the product.

Note that the reverse is also important – developers should be included in the testing process. Doing so allows them to better understand the challenges we face. This input also improves communication and decreases bandwidth loads for everyone.

Whenever possible, all team members should participate – including managers, business analysts, creative, and anyone else whose insight might add value at any stage of the development cycle.

However, coordination is critical or else you run into the problem of too many cooks in the kitchen. See the next point.

5. Responsibilities, Accountability, and Tools
Having everyone on the same page is advantageous – but only if:

  • Someone is in charge to manage the testing process (preferably someone from the testing team)
  • Everyone understands their respective responsibilities, has the right tools to perform their jobs, and appreciates how their contributions impact other team members

Every project is unique, so there’s no universal checklist that applies in all situations. But the Joel Test is still a useful tool for rating a software team’s readiness.

The Most Important Software Testing Resource of All

The above points are vital, but they’ll only get you so far. To truly minimize unnecessary guesswork, you need one final resource. It’s probably the most important ingredient of all.

The software tester.

This should come as no surprise given that software companies invest tons of energy recruiting educated, experienced, and knowledgeable professionals to fill their other departments.

Why wouldn’t testers go through the same screening process?

But in our industry, this is easier said than done. After all, there is no “official” career path for what we do. Testers must develop their skills through experience and continuous self-study. But in the absence of college-level certifications, how do you weed out the qualified from the unqualified?

Here’s a simple rule of thumb:

  • Good testers naturally seek out environments devoid of guesswork.
  • The very best testers create these environments from scratch.