What Is a Test Plan? How to Write One (With Example)

test plan

What a test plan is, the sections it includes, the main types, how to write one in 8 steps, entry and exit criteria, and a filled example for an online store release.

Key takeaways
The 30-second version of this article
A test plan sets the scope, objectives, approach, resources, schedule, and risks for testing one release, plus the entry and exit criteria that decide when testing starts and when it's done.
Write it in 8 steps, from product analysis to review and sign-off, and match its length to the risk: one page for a sprint, a full plan for large or regulated releases.
The test strategy sets the long-term approach and default gates; the test plan applies them to one release with specific scope, people, and dates.
Keep the plan current: revisit scope, risks, schedule, and exit criteria at every sprint or release planning, and version every change.

A test plan turns a release into an agreed testing job: what gets tested, how, by whom, by when, and what counts as done. This guide covers what a test plan is, the sections it includes, the main types, how to write one in 8 steps, entry and exit criteria, a filled example, and how a test plan differs from a test strategy.

If you just need a blank file to fill in, use our test plan template.

What is a test plan?

A test plan is a document that sets the scope, objectives, approach, resources, schedule, and risks for testing a specific release or project. It states what will and won't be tested, how, by whom, and when, and it defines the entry and exit criteria that decide when testing starts and when it's done.

You'll also see it called a software test plan, a QA test plan, a testing plan, or a test plan document. Test planning is the work of writing it and keeping it current. It's usually owned by the QA lead or test manager, with input from developers, the product owner, and anyone who has to sign off on the release.

A test plan does 3 jobs:

  • It gets agreement before testing starts. QA, development, and product agree on scope, approach, and done criteria, so nobody is surprised at release time.
  • It's the basis for estimates. People, environments, and dates come from the scope and approach in the plan.
  • It makes risks visible. Known risks get an owner and a mitigation before they turn into late bugs.

A test plan is not a list of test cases. The plan describes the testing for a whole release; a test case describes how to check one behavior. The plan is one part of your test documentation, and writing it is one of the core activities of test management.

What a test plan includes

The template used on this page has 16 sections. Smaller teams often merge or skip some of them, which is fine as long as scope, approach, entry and exit criteria, schedule, and risks are covered.

Diagram showing the key components of a test plan, including objectives, scope, environment, resources, schedule, deliverables, and risk management.

#

Section

What it answers

1

Document control

Project, release, version of the plan, author, reviewers, approval date

2

Introduction and objectives

Why we're testing this release and what we need to learn

3

Scope

Features in scope and features out of scope, with the reason for each exclusion

4

Test items

Which builds, components, and services are under test

5

Test approach

Test levels, test types, the manual vs automated split, and test design techniques

6

Entry criteria

What must be true before testing starts

7

Exit criteria

What must be true before testing is called done

8

Suspension and resumption criteria

When to pause testing and what has to happen before it restarts

9

Test environment

Browsers, devices, operating systems, URLs, and integrations

10

Test data

Accounts, records, and payment test data, and who prepares them

11

Roles and responsibilities

Who tests, who fixes, who decides, who signs off

12

Schedule and milestones

Test phases, dates, and dependencies on development

13

Test deliverables

Test cases, defect reports, the test summary report, and the traceability matrix

14

Risks and mitigations

What could go wrong, how likely it is, its impact, and the owner

15

Tools

Test management, automation, defect tracking, and CI tools

16

Approvals

A sign-off table with role, decision, signature, and date

The structure goes back to IEEE 829, the original standard for software test documentation. IEEE 829 has since been superseded by ISO/IEC/IEEE 29119-3, which still defines a test plan as one of the core test documents. Neither standard requires a fixed layout: use the sections your project needs.

For the test environment section, name exact versions and URLs rather than "latest browsers". Vague environments are a common reason two testers get different results for the same case.

test better with automation testing tools

Types of test plans

The type of plan you write depends on the size of the release and how many teams are involved.

Master test plan

A master (or high-level) test plan covers a whole project or a large release across several teams or test levels. It sets the overall scope, schedule, environments, and risks, and it points to the more detailed plans below it.

Level-specific test plans

A level-specific test plan covers one test level: unit testing, integration testing, system testing, or user acceptance testing. Each has its own entry criteria, environment, and owners. For example, a UAT plan is often owned by the product team and run by business users. For an integration example, see the integration test plan template.

Type-specific test plans

A type-specific test plan covers one kind of testing that needs its own setup, such as performance, security, automation, or regression testing. A performance test plan, for instance, needs load profiles, a production-like environment, and response-time targets that a functional plan doesn't.

One-page Agile test plan vs full test plan

Many Agile teams don't write a 20-page plan every sprint. A one-page test plan covers the sprint or release goal, scope in and out, approach, test environment, risks, entry and exit criteria (often the definition of done for testing), and the owner and dates.

Use a one-page plan when

Use a full plan when

The release is a sprint or a small increment

The release is large or spans several teams

The team is small and works closely together

Contracts, audits, or regulators expect a signed document

Requirements change often

You need traceability from requirements to results

The test strategy already covers tools and standards

No test strategy exists yet for the product

The two can work together: a master plan for the release, with a one-page plan per sprint that updates scope and risks.

How to write a test plan in 8 steps

Don't write the plan alone. Developers know the architecture and the risky parts of the code, and product owners and business analysts know which features matter most to users. A short review with each saves rework later.

1. Analyze the product and requirements

Read the requirements, user stories, and designs for the release. List the features that change, the systems they talk to, and the dependencies on other teams or third parties, since many defects show up where two modules meet.

Questions to ask stakeholders:

  • What are the main goals of this release?
  • Who uses these features, and on which devices?
  • Which features matter most to customers?
  • What could go wrong, and what would it cost?
  • Which quality or performance standards must the release meet?

2. Set the objectives

Write 2 to 4 objectives that say what testing needs to prove. Make them specific and measurable, for example "confirm a returning customer can pay with a saved card on all supported browsers". Rank them, so the team knows what to drop first if time runs short, and record changes when the objectives move.

3. Define the scope

List the features in scope and the features out of scope, with a reason for each exclusion ("payment provider internals: covered by the provider"). Out-of-scope items are a common source of release-day arguments, so write them down.

Then turn the scope into test scenarios and test cases. If you need a starting point, these feature pages have ready-made examples:

  1. Test cases for login pages
  2. Test cases for registration pages
  3. Test cases for e-commerce websites
  4. Test cases for search functionality
  5. Test cases for API testing
  6. Test cases for banking applications

To write them in a consistent format, use a test case template.

4. Choose the test approach

Decide which test levels and types apply, which techniques you'll use (for example boundary value analysis for input fields), and what gets automated. A practical rule: automate what runs every release and is stable, such as regression and smoke checks, and test manually what is new, visual, or exploratory. If your team has a test strategy, the approach should follow it and only note where this release differs.

5. Plan the test environment and test data

Name the browsers, devices, operating systems, URLs, and integrations you'll test on, and who sets them up. List the test data you need, including valid and invalid inputs, test accounts in each state, and sandbox payment details, and who prepares it before testing starts.

6. Assign roles and resources

List who does what: who writes and runs tests, who fixes defects, who triages, and who signs off. Check what else you need beyond people: hardware, software licenses, testing tools, environments, training, and time.

7. Set the schedule and the entry and exit criteria

Estimate each test phase from the scope and the number of test cases, and tie the dates to development milestones, because testing can't start before the build is ready. Then write the entry, exit, suspension, and resumption criteria, covered in the next section.

8. List risks and deliverables, then review and sign off

Write down each risk with its likelihood, impact, mitigation, and owner. List the deliverables: test cases, defect reports, a traceability matrix, and the test summary report. Then review the plan with these questions:

  • Does the scope cover every requirement in the release?
  • Does every risk have a mitigation and an owner?
  • Is the test environment ready, or booked, for the dates in the schedule?
  • Are the people and tools available when they're needed?
  • Does the schedule fit the release date?

When the answers are yes, get sign-off from the people in the approvals table.

banner6.png

Entry and exit criteria

Entry criteria are the conditions that must be true before testing starts. Exit criteria are the conditions that must be true before testing is called done. Both should be specific enough that 2 people would agree whether they're met.

Your test strategy usually sets team-wide default gates, such as "no open critical or high defects at release". The test plan applies those defaults to one release and adds anything specific to it. At the end, the test summary report checks each exit criterion and says whether it was met.

These are examples to adapt, not targets to copy:

Entry criterion

Example

Confirmed by

Build deployed

Release candidate deployed to the staging environment

DevOps

Smoke tests pass

All smoke tests pass on the new build

QA engineer

Test cases ready

High-priority test cases written, reviewed, and published

QA lead

Test data ready

Test accounts and sandbox payment data loaded

QA engineer

Environment ready

Supported browsers and devices available and configured

DevOps

Exit criterion

Example

Confirmed by

Execution

All high-priority test cases executed

QA lead

Defects

No open critical or blocker defects

QA lead and dev lead

Pass rate

All highest-priority (P1) test cases passed; any target for lower priorities is agreed by the team

QA lead

Coverage

Every in-scope requirement has at least one executed test

QA lead

Accepted risks

Remaining open defects reviewed and accepted by the product owner

Product owner

Report

Test summary report shared with stakeholders

QA lead

Avoid an overall pass rate on its own: a high pass rate can still hide a failing checkout. Pair any pass rate with a severity rule like "no open critical or blocker defects".

Suspension and resumption criteria

Suspension criteria say when to stop testing because continuing would waste effort. Resumption criteria say what must happen before testing restarts. For example:

  • Suspend when a blocker defect stops testing of a core flow such as checkout or payment, when the test environment is down for more than 4 hours, or when the build fails smoke tests.
  • Resume when the blocker is fixed and retested, a new build passes the smoke test, and the environment has been stable for an agreed time (1 hour in the example below).

Running a quick sanity test or smoke test on every new build catches unstable builds before the full test cycle starts.

Test plan example

This example is for a fictional online store. Release 4.2 is a web release that replaces the three-step checkout with a single-page checkout and lets signed-in shoppers save a card for later orders. It shows the key sections only. All names, dates, and URLs are illustrative.

Section

Release 4.2 example

Objectives

Confirm shoppers can complete a purchase with the new checkout on every supported browser and device; confirm saved cards are added, shown, used, and removed correctly, and that the store never shows or keeps full card numbers; confirm existing flows (cart, promo codes, guest checkout, order history) still work; give the release manager a go or no-go recommendation backed by test results

In scope

Single-page checkout (shipping address, delivery options, payment, order review); save, choose, and remove a saved card; guest checkout; promo codes and gift cards at checkout; order confirmation email; regression of cart, sign-in, and order history

Out of scope

iOS and Android apps (tested in their own release); payment provider internals (covered by the provider's own certification); warehouse and shipping systems after an order is placed; full load testing (planned for release 4.3)

Test approach

Levels: unit and API (developers), integration, system, and user acceptance testing (product team); types: functional, regression, cross-browser, accessibility (WCAG 2.2 AA), security checks on saved cards, and a performance smoke test; regression of cart, sign-in, and checkout happy paths automated and run on every build in CI; exploratory testing of the new checkout, the accessibility review, and UAT done manually

Entry criteria

Release candidate deployed to staging and the smoke test passes; requirements and designs signed off; test cases reviewed and linked to requirements; test data and payment sandbox accounts ready; no open critical defects carried over from the previous build

Exit criteria

All P1 and P2 test cases executed, and all P1 cases passed; no open critical or high defects, and medium defects have an agreed fix date or workaround; automated regression suite passes on the final release candidate; accessibility review finds no blocking issues; UAT signed off by the product manager; test summary report shared with the release manager

Test environment

Staging and UAT URLs; Chrome, Firefox, Safari, and Edge (latest two versions); Windows laptop, MacBook, iPhone and Android phone (mobile web), and iPad; payment provider sandbox, test email inbox, and tax calculation service in test mode

Schedule

Planning and case design 2026-11-09 to 2026-11-13; test cycle 1 2026-11-16 to 2026-11-20; fixes and retest (cycle 2) 2026-11-23 to 2026-11-27; regression and UAT 2026-11-30 to 2026-12-02; go or no-go meeting 2026-12-03; release 2026-12-08

Risks

Payment sandbox slow or unavailable (medium likelihood, high impact; mitigation: book sandbox time early and mock payment responses for non-payment tests; owner: engineering lead); late design changes to checkout (medium, medium; mitigation: freeze designs on 2026-11-13; owner: product manager)

Want this as a file? The test plan template has this website release filled in for all 16 sections, plus a one-page Agile version in the Excel file. The test summary report example checks the same release against these exit criteria.

Test plan vs test strategy

A test strategy sets the long-term approach to testing for a product or organization and changes rarely. A test plan applies that approach to one release or project, with specific scope, people, dates, and criteria.

Aspect

Test plan

Test strategy

Covers

One release, project, or test level

A product, program, or organization

Answers

What, when, who, and on which environments

How we test in general, and to what standard

Owner

QA lead or test manager

QA lead or head of QA

How often it changes

Every release or sprint

When the product, architecture, or risk profile changes

Entry and exit criteria

Specific gates for this release

Team-wide default gates

Contents

Scope, test items, schedule, environment, data, roles, risks, approvals

Test levels, test types, automation approach, tools, defect process, metrics

Example

"Release 4.2: run regression and UAT on staging from 2026-11-30 to 2026-12-02 on Chrome, Firefox, Safari, and Edge, owner QA lead"

"Automate regression for all checkout flows and run it on every release candidate"

Both are living documents, and a plan doesn't need to be rigid. In Agile teams the plan changes every sprint, while the strategy stays steady. For a full guide to the other document, see our test strategy guide.

Keeping a test plan current in Agile

A test plan written once and never opened again is worse than a one-page plan that's up to date. In Agile teams, keep a short master plan for the release and revisit these sections at every sprint planning: scope in and out, risks, schedule, and exit criteria.

When something changes, update the plan in 4 steps:

  1. Find the reason for the change. What changed, and how does it affect the release goals?
  2. Check the impact. What new risks does it bring, and how does it affect the schedule, people, or environments?
  3. Update the affected sections. Sections depend on each other: a scope change usually means new test cases, test data, and dates.
  4. Review the change with the people who signed off. Record the new plan version in document control so everyone works from the same plan.

Test plan management tools

Many teams keep the test plan document itself in a wiki, a shared drive, or a template, and track the work it describes in a test management tool. The tool holds the requirements, test cases, runs, and results, so you can see progress against the plan without updating a spreadsheet by hand. For a comparison of options, see our guide to the best test management tools.

In Katalon TestOps, the test plan document stays outside the tool, but the work it describes is tracked inside it:

  • Releases and sprints: with Jira or Azure DevOps connected, the Plans module shows release and sprint schedules, the requirements in each, and the test runs per release. You can assign testers to requirements and link or create test cases for them.
  • Test suites and runs: test suites group the test cases for a release scope, such as smoke or regression. A manual test run records the executor, release, sprint, and target configuration, such as Windows 11 and Chrome. Automated runs can be scheduled, for example a nightly regression.
  • Exit criteria as gates: a Project Admin can set readiness criteria per release or sprint, such as a minimum requirement coverage, a minimum pass rate, and blocking-defect rules by priority and severity. The Release Health dashboard shows Ready only when every gate passes. Defect rules need a Jira or Azure DevOps integration.
  • Coverage and traceability: the Requirement Coverage Analysis Report shows which requirements are not, partially, or fully covered, and the Requirement Traceability Report links each requirement to its test cases, each test case to its executions, and each execution to its defects. Both need requirements linked to test cases, and the traceability report also needs Jira or Azure DevOps connected.

If you use Azure DevOps Test Plans, you can link those test cases to Katalon test cases and push run results to an Azure DevOps test plan and suite.

Test plan best practices

  • Write it with the people who'll use it. A plan reviewed by development and product is more likely to be followed; a plan written alone often gets ignored.
  • Match the length to the risk. One page for a sprint, a full plan for a large, regulated, or contract release.
  • Write the out-of-scope list first. It forces the hard conversations early.
  • Make every criterion checkable. "No open critical or blocker defects" can be checked. "Quality is acceptable" can't.
  • Give every risk an owner. A risk without an owner rarely gets mitigated.
  • Name exact environments. Browser versions, devices, and URLs, not "all major browsers".
  • Link the plan to requirements. A traceability matrix shows which requirements are tested and which aren't.
  • Version the plan. Record each change in document control, so the sign-off matches the plan that was actually followed.

Frequently asked questions

Huyen Nguyen
Huyen NguyenTechnical Writer, Katalon

Huyen Nguyen is an experienced technical writer in the software testing industry. With strong technical expertise and a deep understanding of Katalon products, she creates clear, practical guides that support testers at every skill level.

Connect on LinkedIn →
Get started

Test everything. Ship with confidence.

From generating test cases to spotting failures, Katalon's AI works across your entire pipeline, automatically.

The Next Evolution of Manual Testing: Introducing Katalon AI Test Runner

Introducing Katalon AI Test Runner. Watch it run manual test cases live, with evidence for every pass and fail.

Live webinar
9:00 to 10:00 AM EST · Live online
Alex MartinsVP of Strategy
Gia EspositoSenior Solutions Engineer
Save your seat