The Test Plan Template: Your Key to Optimizing Software Testing

Imagine if Google broke. That one day, it just stopped working.

I know it’s a scary thought…

In 2013, Google actually did break, although, only momentarily (for a whole 5 minutes to be exact). The outage affected all of its services, meaning Youtube, Gmail, Google search, Google Maps … everything stopped working.

The outcome?

Global web traffic plummeted by a whole 40% and the blip is estimated to have cost Google around $500,000.

If your product or service suddenly stops working as intended, then it’ll cost your organization a hefty sum, too.

That’s why, in this quick but informative Process Street post, you’ll learn all about test plan templates and how to use one yourself to ensure your product or service runs like a well-oiled machine. All-day, every day.

Alternatively, to jump to a specific section, click appropriate the link below:

• What is a test plan?
• What is a test plan template?
• Where the software test plan began
• Best practices for creating a test plan template
• Software test plans today
• How to write a test plan template

Let’s get started!

“A test plan is a document describing the scope, approach, resources, and schedule of intended test activities.” ISQTB, Test Plan

A test plan identifies what it is that will be tested, or, the test items; features; tasks, and so on. It also identifies who will do the test or be included in the testing process; the test environment, and the test design techniques.

In other words, a test plan is a plan for all of the software testing you need to do.

A template is just a blueprint to help you complete regular recurring tasks; in this case, a test plan template walks you through each item that needs to be tested. Alongside the items, the template will also guide you in testing features, specific tasks, and so on.

In simple terms, a test plan template serves to conduct software or application testing activities by following a defined process.

It is a strategy built up of objectives, schedules, estimations and deliverables, and the resources required for testing. The plan strategically tests all of the above to ensure the application or software you are testing is optimized and functioning properly.

As demonstrated by the Google example, running a test plan on a regular basis is fundamental to ensure the success of your software. It is essential to mitigating blips.

To give you a visual depiction I’ve embedded Process Street’s test plan template below:

Click here to get the Test Plan Template.

In 1979, Glenford Myers published a book that turned out to be a classic in the IT world: The Art of Software Testing. Myers’ book gave the tech industry a long-lasting, foundational guide ensuring that the software you produce does what it is designed to do.

Myers created a philosophy and a process that functioned across previous, current, and unforeseeable future hardware and software platforms.

To be more specific…

He separated fundamental development activities, such as debugging, from that of verification.

Testing is the process of executing a program with the intent of finding errors. A good test case is one that has a high probability of detecting an undiscovered error.

A successful test case is one that does indeed detect an undiscovered error. So, through software testing, you are aiming to verify everything works correctly by searching for problems.

But with debugging, you already know that a fundamental problem exists as a result of the original test. It is what you do after you have executed a successful test case.

Debugging is a two-step process that begins when you find an error as a result of a successful test case.

• Step 1 is the determination of the exact nature and location of the already known error within the program.
• Step 2 consists of fixing the error.

In other words, before Glenford Myers, there wasn’t such a methodical, useful way for going about testing properly. So in order for a bug to be resolved, something had to stop working or had to occur.

The Google example provided evidence of just how costly a blip can be for present-day web users. This is worrying when you consider that Glenford Myers’ book was published way back in 1979 – over 40 years ago!

Let’s take a closer look at Google and present-day software testing.

“In October 2019, Google was ranked first amongst the most visited multi-platform web properties in the United States with close to 259 million U.S. unique visitors and a market share of 62.5 percent among the leading U.S. search engine providers.” J. Clement, Google – Statistics & Facts, Statista

Considering the mass sum of visitors relying on their software, Google constantly needs to ensure that their systems are running optimally.

Let’s say a test plan is run and it finds a bug that will affect 0.01% of the user base of a small app (about 1000 users) – fixing the issue wouldn’t be a priority. However, if the same situation occurred for Google, that’s magnitudes more users, and thus complaints to deal with.

So, what does Google do to prevent such a disaster occurring?

Of course, they employ a lot of testers to help eek out the bugs and issues with all of their software and user experiences.

“Testers are essentially on loan to the product teams and are free to raise quality concerns and ask questions about functional areas that are missing tests or that exhibit unacceptable bug rates.” James Whittaker, How Google Tests Software

But testers alone are only a part of the whole – Google has a rigorous system for processing and resolving bugs identified by their testers, which is where the idea of a test plan becomes crucial.

If we were to break Google’s approach to software testing into a step by step process, according to Glenford Myers, it would look something like this:

1. The developers develop a product.
2. The testers test the product.
3. Developers fix any bugs or issues encountered by testers in the testing process.

This back and forth process highlights the importance of having a test plan – and Google likely has various test plan templates that help to facilitates communication between team members across various different situations and test cases. Having a clearly defined process for this kind of task helps to streamline new code for release, by allowing lead developers to approve changes after they have been thoroughly tested.

Process Street’s approvals feature allows for exactly that: On top of streamlining the overall decision-making flow, it helps to facilitate communication and ensure only high-quality items get approved.

In the context of software testing, testers would be able to send results or notes from their testing session to team leads for approval or rejection at the click of a button.

To learn more about how you can use the approvals feature within Process Street, check out this webinar:

The way Google explains its approach to software testing is that it separates tasks to allow for accountability. Google ensures that the product team is responsible for the quality of what they produce.

Whilst the testers focus on writing automation and have their own set of priorities such as reliability and security.

The benefits of Google’s approach

• Firstly, as the product is not their baby and is not something they’ve been developing for months on end, testers are less inclined to take shortcuts.
• Secondly, the “on-loan” nature of testers means that they are constantly moving around sharing new ideas and energy throughout the company; whilst also encouraging developers to meet deliverables on time.
• Finally, developers can focus on producing great code and don’t have to spend too much time worrying about testing.

One last interest point to make: As you might expect from a company known to build and develop its own version of everything …

Google has its own tool for testing — the Google Test Case Manager.

So there’s some history around the concept of software testing and planning, as well as how Google still operates around software testing to this day.

Now, let’s take a look at some of the best practices for creating a test plan template:

• Ensure the plan is concise. Be strict with your plan: If a section isn’t bringing actionable value to the plan, delete it
• Be specific. A test plan template is designed to be edited to meet the specific requirements of that particular test. Be precise and detail exactly which feature you are testing (for example)
• Make sure the test plan is scannable. Avoid long paragraphs and use lists and tables when possible
• A successful test plan requires a team effort. Have the test plan reviewed at least once. And, always remember to send it for approval
• Always check you are running the most up-to-date plan. Have you ever started editing something only to find you’ve already made the edits in another location? I certainly have and it wastes so much time!

Pro tip: To mitigate that final point, include a “enter basic information” task in your test plan templates. And, make sure this task is mandatory by using a stop task. This will help you to keep track of exactly who made edits and when they did so.

Like any blueprint or strategy, a test plan template needs structure.

The first step in your test plan is to identify why whatever it is that is being tested, be it a new feature, software update, and so on, is valid and important. Ask yourself questions like: What will the feature be used for? Who will use it? Does it work?

If not, why doesn’t it work?

Test plan template — Step 1:

This is where you identify the scope of the project.

For example, say the purpose of your test plan is to test the feasibility and performance of a selected feature.

The scope would be something along the lines of …“the feature” will be tested at an early stage across all system and subsystem interfaces alongside the overall system performance.

Test plan template — Step 2:

What are you testing?

Use this step to identify the code you intend to test and create a list of what is being tested.

This step will be informed by the information you identified when determining the scope of your test plan.

Features to be tested: This is a list of what is to be tested from the user’s point of view concerning what the system actually does. This is not a technical description of the software but rather the user’s viewpoint of the software’s functions.

Pro-tip: It is best practice to identify the test design specifications that are associated with each feature or set of features in this step.

Features not to be tested: This is a listing of what is not to be tested from both the user’s viewpoint of what the system does and a configuration management/version control view.

This is not a technical description of the software but a user’s view and understanding of the functions of the software.

Test plan template — Step 3:

How will you approach the testing of the software?

This is your overall test strategy; this is where you detail the methods you intend to use for the testing process.

Test plan template — Step 4:

What does the software need to do to pass the test?

This a critical aspect of any test plan. The goal is to identify whether or not a test item has passed the test process, and if not, why not. This is where you determine what criteria will merit a suspension of the feature and its resumption requirements.

Test plan template — Step 5:

What is to be delivered as part of this plan?

Include the following:

• Test plan
• Test design specifications
• Test case specifications
• Test procedure specifications
• Test item transmittal reports
• Test logs
• Test Incident Reports
• Test Summary reports
• Test Incident reports

Test plan template — Step 6:

This section should include tasks that identify and illustrate test deliverables. The outcome of each test task should then interlink to corresponding tasks depending on the result.

You could think of each of the tasks coming together to form a super-powered checklist, which is, simply put, what we do here at Process Street. Creating interlinking or corresponding tasks with tailored outcomes is super easy using Process Street’s conditional logic feature.

To learn more about how this feature works check out this video:

In fact, Process Street has heaps of useful features that can help you create corresponding tasks, superpowered checklists, and ultimately a faultless test plan template.

Bonus software development resources

I have already briefly introduced you to a few pre-made templates and checklists throughout this post.

But, if you haven’t signed-up and checked some of these out yet, now is a great time to do so – signing-up takes less than a minute, and it’s completely free.

How to super-power your test plan template

Process Street is superpowered checklists.

Check out the demo video below to gain an understanding of how you can use Process Street to create test plan templates, checklists, and ultimately automate recurring workflows.

In case you need persuading further, here are a few more pre-made templates that relate specifically to the software testing and debugging arena:

Software Testing Checklist

To help you avoid as much human error as possible, we decided to build our own software testing tutorial!

Follow this this checklist to carefully check individual sections of your software’s code and make sure everything’s running as expected before deployment.

Click here to get the Software Testing Checklist.

Software Debugging Checklist

Found a bug in your code?

Using this software debugging process will help you resolve your bugs step-by-step. Starting from breaking down the problem into manageable tasks to reviewing and applying the solution.

Click here to get the Software Debugging Checklist.

Software Deployment Checklist

Deployment is serious business.

You can’t just rely on your memory that all the bugs have been fixed and hope all goes well. This would leave way too much room for error and could potentially set you back weeks or worse, even shut the project down for good.

That’s why we built this software deployment checklist; to make sure that every issue you had with your software was fixed when it was supposed to be and is ready to launch.

Click here to get the Software Deployment Checklist.

And finally — although you’ve probably guessed considering you’ve read this far — but we regularly post incredibly insightful content on our blog.

Here are some more relevant articles we’ve done on software development and testing:

• Software Testing Methods: How Google and Facebook Crush Quality Assurance
• 4 Types of Software Testing and When You Should Use Them
• 15 Load Testing Tools, Tips and Methods to Protect You from Crashes

There you have it. You’re now well-versed in test plan templates, software testing, and how to use Process Street for your own test plan template!

We’d love to hear about the different ways you use test plans for your software testing in the comments. Share any useful tips and tools below!