
Most test plan templates you will find are derived from IEEE 829 and run to twenty sections. They are thorough, and almost nobody fills one in honestly, because a form that takes a day to complete gets completed the way a form that takes a day gets completed.
This is the short version. Six sections, a few lines each, written so that a person reading it in three weeks can tell what was agreed. Copy it, delete what does not apply, and keep it beside the work rather than in a documents folder nobody opens.
Here is the whole thing:
# Test Plan: [what is being tested]
**Release / build:** [version or branch]
**Owner:** [who decides whether this passed]
**Date:** [when this was agreed]
## In scope
What will be tested, in plain language. One line per area.
- [area, and what about it]
- [area, and what about it]
## Out of scope
What will NOT be tested this time, and why. This is the section that earns
the document. Write it even when it feels obvious.
- [thing]: [why not - no change, covered elsewhere, accepted risk]
- [thing]: [why not]
## How it will be tested
- Environments: [which, and on what data]
- Browsers / devices: [the real list, not "all browsers"]
- Manual or automated: [which parts, by whom]
## Entry criteria
What has to be true before testing starts.
- [e.g. build deployed to staging and smoke test passing]
- [e.g. test data loaded]
## Exit criteria
What has to be true before this can be called finished. Agree these before
testing, not after.
- [e.g. no open defects at severity 1 or 2]
- [e.g. every in-scope area executed at least once]
- [e.g. known issues listed and accepted by name]
## Risks
What could stop any of the above working, and what happens if it does.
- [risk]: [what we would do]
The three sections people skip, and what each one prevents
Out of scope is the one that earns the document, and it is the one most often missing. Anybody can list what they intend to check, and nobody argues about that later. The argument three weeks after release is always the same shape: somebody assumed an area was covered, because nobody ever said out loud that it was not. Four lines converts a silent assumption into a decision made on purpose, with a reason attached, at the moment when saying so was cheap.
Exit criteria decide when testing is finished, and writing them afterwards is how they end up meaning “we ran out of time”. Agree them while nobody is under pressure and they are a standard. Agree them on the last afternoon and they are a negotiation.
Entry criteria are the cheapest of the three and save the most wasted days. A build that was never deployed, or a staging database with no test data in it, costs a tester half a day before anybody works out that the problem is not in the software. One line stops that.
What to delete
Most of it, on most projects. The template is a starting point and not a checklist of things you owe somebody.
Delete the risks section on a small change. Delete entry criteria if your deploy is automatic and the environment is always ready. Collapse “how it will be tested” to one line if there is only one environment and one browser that matters. A test plan that is six lines long and true is worth more than two pages of sections filled in to look complete, and the person reading it in three weeks will be grateful.
What you should not delete is out of scope, even on a one-line change. Especially on a one-line change, because that is exactly when somebody assumes the rest was checked.
Where this sits
A test plan says what will be tested and what will not. It is not a test case, which is the instructions for checking one specific thing, and it is not a bug report. If you want the reasoning behind each section rather than the artefact, what a test plan is for covers the same ground as an explainer.
Session Replay
Free Chrome extension. One click on the page that is misbehaving captures the screenshot, the console and the network log, and hands you a link to paste into the ticket.
One thing worth adding to the plan itself
A line in how it will be tested naming how a defect gets reported. Not the tracker, which everybody knows, but what a report has to carry before somebody will act on it: the build, the browser, the steps, and the console if there was one.
Agreeing that on the first day is the difference between a defect list that can be worked through and one where half the entries need a conversation before anybody can start. It costs one line in a document you are writing anyway.