How to write a software test plan for a web app
A software test plan is done when every section is filled or marked "not applicable". Until then it is a wish.
This post shows how to write one for a web app: the nine sections and six steps, with a plan filled in for Kimai, an open-source time tracker. It is for QA leads and developers at small SaaS teams. The plan you write here feeds your test cases, and those feed your automated regression testing for web apps.
What is a software test plan?
A software test plan is a document that states what you test in a release, how you test it, who does the work and when you stop. It replaces a vague "we will test the app" with a scope and end criteria that the team agrees on before the first test runs.
The standard that names it is ISO/IEC/IEEE 29119-3:2021. It replaced IEEE 829, which Wikipedia's entry on software test documentation records as superseded. The Wikipedia entry on test plans still teaches the IEEE 829 outline. The current clause names differ, and we use them below.
What goes into a software test plan?
A software test plan has nine sections, named after the test plan clauses of ISO/IEC/IEEE 29119-3:2021. Each one answers a single question:
- Context of the testing. What is the app, and which parts are in and out of scope?
- Assumptions and constraints. What do we take as given, and what limits us?
- Stakeholders. Who needs the result, and who signs off?
- Communication. Who gets which report, and how often?
- Risk register. What must not break, and how likely is it?
- Test strategy. Which kinds of tests, in which environment, and when is testing done?
- Activities and estimates. What work is needed, and how long will it take?
- Staffing. Who does what, and who needs training?
- Schedule. What happens when, and when is the sign-off?
Here is what each section looks like for a web app, such as an online shop with a checkout and an admin area:
| Section | Question it answers | Example for a web app |
|---|---|---|
| Context | What is in scope? | Checkout and admin area; Chrome on a laptop, Safari on a phone |
| Assumptions and constraints | What do we take as given? | The test environment holds sample data; payments run against a sandbox |
| Stakeholders | Who needs the result? | Product owner and developers |
| Communication | Who gets which report? | A short test report after every full run, sent to the product owner |
| Risk register | What must not break? | A lost order is priority P0; a rarely used export is P2 |
| Test strategy | Which tests run, and when is testing done? | Tests ordered by priority; done when 80% of test cases pass and no P0 case fails |
| Activities and estimates | What work, and how long? | Crawl the app, write the spec, write test cases, review them |
| Staffing | Who does what? | One QA lead, one developer who fixes what fails |
| Schedule | What happens when? | Code freeze on Monday, sign-off on Thursday; a user acceptance test plan adds the client's acceptance date |
What is the difference between a test plan and a test strategy?
A test strategy is the standing approach to testing in a team or product, and a test plan applies it to one release. The strategy says "we run automated tests on every build". The plan says which tests run for release 4, in which environment and by when.
| Test strategy | Test plan | |
|---|---|---|
| Scope | A team or a product | One release |
| Lifetime | Years; changes rarely | Weeks; written again per release |
| Owner | QA lead or engineering lead | QA lead, with the product owner |
| Example | "Automate the checkout path on every build" | "Release 4: 120 test cases, sign-off on Thursday" |
ISO/IEC/IEEE 29119-3:2021 keeps the two close: the strategy is the sixth section of the plan. A small team can write the strategy once, in a paragraph, and reuse it in every plan.
How do you write a software test plan in six steps?
Write the plan in this order: read the app, set the scope, rank the risks, fix the end criteria, name the people, and map the plan to test cases. Each step has a way to go wrong, and the list names it, so you can check your own plan against the same traps.
- Read the app before you write. Log in as each role and note the pages and the actions. A plan written from the requirements alone describes tests nobody runs.
- Set the scope and the role by device matrix. List the roles and the devices, then multiply them. Three roles on two devices make six combinations, and a role or device left out gets no tests.
- List the risks and give each a priority. Rank by what hurts if it breaks: P0 for lost data or money, P3 for cosmetics. Without a ranking every test case looks equally urgent.
- Set end criteria you can measure. "Enough testing" is no criterion. A pass rate of at least 80%, and zero failing P0 cases, is one. Add an entry criterion too, such as a stable build on the test environment, so testing starts from a fixed state.
- Name people, dates, the test environment and the build under test. Put a name next to each activity and a date next to each milestone. A section without a name gets skipped, and you find out at sign-off. An environment that differs from production hides the bugs your users will find.
- Map every line of the plan to test cases. Priority and devices must land in the fields of a test case. A plan that no test case refers to is shelfware, so don't write one.
What does a filled-in test plan template look like? Example: Kimai
The Kimai plan holds six Playwright projects, about 350 test cases and a pass gate of at least 80%. We wrote it for Kimai, an open-source time tracker, and ran it with AI coding agents.
Kimai has three roles. The super admin and the regular user log in; the visitor does not. Each role runs on Desktop Chrome and on an iPhone 13, so the plan holds six Playwright projects.
| Section | Kimai plan |
|---|---|
| Context | A time tracker with timesheets and an admin area; three roles on two devices, six Playwright projects |
| Test strategy | About 350 test cases, worked in priority order, P0 first; done at a pass rate of at least 80% |
| Activities and estimates | Crawl, spec, test cases, review and fixes took about 91 minutes of agent time for 350 test cases |
| Staffing | Up to six AI coding agents, and one person who reviews the test cases |
Two sections changed the most. The end criteria and the risk register mattered more than we expected, because the backlog is worked in priority order and the pass gate is a number. The list of test items turned out to be unnecessary: the spec from the crawl already is that list.
In the latest full run of the Kimai suite, the pass gate of 80% passed on 98 of 98 results (96 pass, 2 pass with one check skipped), which cover only 55 of about 350 test cases, on one app. Those 98 results are one test case in one project each, so the number says little about the other 295. A plan should state this limit next to the number.
The figures come from the Kimai case study and the public report on the run. Versions: Kimai 2.67.0, Playwright 1.49.0 and Chromium 131.0.6778.33. Method: the effort figure is agent time for the crawl, spec, test cases, review and fixes of 350 test cases. It comes from one app, Kimai, and does not show human time or the result on another app.
What does the plan hand to each test case?
The plan hands four things to every test case: a priority from the risk register, the projects from the role by device matrix, the end criterion from the strategy, and the risks to cover. The test case adds the steps and the checks. Our guide on how to write test cases covers the cases themselves.
Each of our test cases holds a user story with steps, and acceptance criteria that are plain pass or fail. It also holds absence checks, which say what must not happen. Here is one from the Kimai run, TC-WEB-001: a regular user works on the timesheet and the dashboard between login and logout.
- Acceptance criteria: after logout, opening the dashboard or the timesheet redirects to the login page.
- Absence check: after logout, the Back button shows no protected page content.
The redirect check passed. The Back button still showed the dashboard. Kimai sends Cache-Control: max-age=0, must-revalidate, private without no-store, so the browser serves the cached page on a shared computer.
In TC-WEB-002 the super admin's Back button also showed the dashboard after logout. The agents could not make the Back-button check of TC-WEB-001 or TC-WEB-002 pass with a test change, so they marked both cases blocked and a person decides what to do about the app. A plan that listed only "login works" would have missed this.
The skill that writes these cases is open source: qa-write-test-cases on GitHub.
What changes in the plan when the app changes?
The plan changes when the app changes. After a release, check two things: did a new role or device appear, and did a risk change its priority. Edit the plan in those places only.
We re-run the crawl after every change to the app. Test cases that did not change stay as they are, and a test whose test case changed is flagged for a rewrite. That upkeep is what automated regression testing for web apps is about, and it works only when the plan says what to protect.
When is a short checklist enough?
A nine-section plan is too much for a one-page site, or for a team that releases rarely. For them a short checklist, run before each release, does the job.
A nine-section plan is too little for regulated work. If a client or an audit requires the full document set of ISO/IEC/IEEE 29119-3, the nine sections are a start; the standard asks for more.
FAQ
What is the difference between a test plan and a test case?
A test plan covers a whole release: scope, risks, end criteria, people and dates. A test case covers one behavior of the app, for example that a user can log out safely. The plan sets the priority and the devices for each test case. One plan usually points to hundreds of test cases; our guide on how to write test cases shows what one holds.
How long should a software test plan be?
As long as it takes to fill the nine sections, and no longer. For a small web app that is a few pages. The test cases live in their own files and stay out of the plan. A plan that keeps growing usually repeats the spec, so link to the spec instead of copying it.
Do agile teams need a software test plan?
Yes, a short one: write it once per release or per quarter, not per sprint. It holds the risks and the end criteria, which change slowly. Sprint-level detail belongs in the backlog and the test cases. Update it only when the app or its risks change.
Is IEEE 829 still used?
In places, yes: the Wikipedia entry on test plans still teaches its outline, but the standard was superseded by ISO/IEC/IEEE 29119-3. The old items such as test items and risks map onto the new sections. If a client asks for IEEE 829, you'll want to ask whether they mean the current standard before you build the document. The sections are close enough that one plan can usually serve both.
The Kimai case study: hours and costs of 350 test cases, from the plan to the passing tests.
See the measured run on Kimai