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.
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.

# | 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.

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:
- Test cases for login pages
- Test cases for registration pages
- Test cases for e-commerce websites
- Test cases for search functionality
- Test cases for API testing
- 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.

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:
- Find the reason for the change. What changed, and how does it affect the release goals?
- Check the impact. What new risks does it bring, and how does it affect the schedule, people, or environments?
- Update the affected sections. Sections depend on each other: a scope change usually means new test cases, test data, and dates.
- 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
A test plan gets QA, development, and product to agree on what will be tested, how, by whom, and when, and on what counts as done, before testing starts. It is the reference for estimates, risks, and sign-off, so release decisions are based on agreed criteria rather than opinion.
Usually the QA lead or test manager. Developers, the product owner, business analysts, and DevOps contribute their parts, such as technical risks, priorities, and environments, and the people in the approvals table review it before testing starts.
It depends on the size and risk of the release. A one-page plan for a sprint can be written in a short session with the team. A master plan for a large or regulated release takes longer, mostly because of reviews and sign-off. Starting from a template saves time on structure.
A test plan describes the testing for a whole release: scope, approach, environments, schedule, and criteria. A test case describes how to check one behavior, with preconditions, steps, test data, and an expected result. See how to write a test case.
A long, formal document usually isn't. Many Agile teams keep a lightweight plan per release or a one-page plan per sprint, covering scope, approach, environment, risks, and the definition of done for testing, and update it as the backlog changes.
IEEE 829 is the original IEEE standard for software test documentation. It defined documents such as the test plan, with sections like suspension criteria and approvals. It has been superseded by ISO/IEC/IEEE 29119-3, which is the current international standard for test documentation, including test plans.
It's usually a document with numbered sections: document control, objectives, scope in and out, approach, entry and exit criteria, environment, test data, roles, schedule, risks, deliverables, and a sign-off table. Agile teams often cut it to a one-page table with scope, approach, environment, risks, and done criteria per sprint.
Whenever scope, risks, schedule, or environments change, and at least at every sprint or release planning. Record each change as a new version in the plan's document control section so everyone works from the same version.

Test everything. Ship with confidence.
From generating test cases to spotting failures, Katalon's AI works across your entire pipeline, automatically.



