Test Strategy
Deciding what to test, at which level, and what not to test at all — written down, so it is a choice rather than an accident.
3 min read · updated 19 September 2026
Most teams have an implicit test strategy. It usually amounts to write tests for the things that are easy to write tests for, and it shows in the shape of the pyramid and in which module turns out to be uncovered when something breaks.
A strategy is the same decision, made deliberately and written down. It should fit on one page.
#Four questions
#1. What are we trying to prevent?
Not "bugs". Specifically:
- A customer being charged twice
- An order silently not reaching the warehouse
- One tenant seeing another tenant's data
- The site being down during a campaign
- A migration that cannot be rolled back
That list is short, specific to your business, and it determines everything else. An e-commerce team and a medical device team write very different lists and should have very different suites.
#2. What is each level responsible for?
Unit every branch of business logic; no I/O; runs in seconds
Integration every seam with something we did not write
Component each service's HTTP contract, including authorization
Contract that independently deployed services still agree
End-to-end the six journeys that would end the business
Exploratory everything we did not think of
Production monitoring and alerting as the final layer of testingWriting this down settles the recurring argument about where a given test belongs, and it makes gaps visible. If nothing on that list owns "authorization", nothing is testing it.
#3. What are we not going to test?
The part everyone skips, and the most useful.
NOT TESTED, DELIBERATELY
- Internet Explorer and any browser below 1% of sessions
- The admin CSV export (internal, two users, obvious when broken)
- Email rendering across clients (we accept it may look wrong in Outlook)
- Localisation beyond en-GB and fr-FR
- Load beyond 3x current peakEvery team has a list like this. The difference is whether it was chosen or discovered at 2am. Writing it down converts an unknown risk into an accepted one, and makes it reviewable when the business changes.
#4. How will we know this is not working?
Leading indicators, so the strategy can be corrected before an incident teaches you:
- Escaped defects — bugs found in production, by area. The distribution tells you where the strategy is wrong.
- Flaky rate — above ~1% and people stop trusting red.
- Pipeline duration — over ~15 minutes and people stop waiting for it.
- Areas at zero coverage — a direct statement of what is unprotected.
#Risk-based prioritisation
Testing is a cost paid to reduce risk. Spend it where risk is highest.
| Area | Likelihood | Cost of failure | Investment |
|---|---|---|---|
| Payment capture | medium | catastrophic | unit + integration + contract + e2e + monitoring |
| Authorization | medium | catastrophic | exhaustive API-level matrix |
| Search relevance | high | low | a few unit tests; iterate in production |
| Admin export | low | low | none; fix on report |
| Onboarding flow | medium | high | e2e journey + exploratory each release |
The interesting rows are the cheap-failure ones. "Search relevance is not worth automated testing, we will iterate on it in production" is a legitimate and often correct strategic decision, and it is only available to a team that has decided it rather than drifted into it.
#What a strategy is not
Not a test plan per feature. Those are artefacts of a process that produces documents; strategy is the standing decision that removes the need for most of them.
Not a coverage target. See code coverage — a number without a risk model behind it produces tests written to move the number.
Not a tool choice. Tools are downstream. A team that cannot say what it is trying to prevent will not be saved by picking Playwright.
#Writing it down
One page, in the repository, next to the code:
# Test strategy
## What we are protecting
1. No customer is charged for something they did not receive.
2. No tenant can see another tenant's data.
3. Checkout works, every day, on Chrome, Safari and mobile Safari.
## Who tests what
- Developers: unit, integration and component tests for everything they write.
- The suite: six e2e journeys, tagged @critical, run on three engines.
- Everyone: exploratory testing for one hour before each release.
## Deliberately not tested
- Browsers below 1% of sessions (reviewed quarterly).
- The internal admin export.
- Email rendering outside Gmail and Apple Mail.
## How we know this is failing
- Escaped defects by area, reviewed monthly.
- Flaky rate over 1%.
- Pipeline over 15 minutes.
Reviewed: 2026-09-19. Next review: 2026-12-19.The review date is what stops it from becoming archaeology. A strategy written for a product that has since changed is worse than none, because people still believe it.
Common questions
- What should a test strategy document contain?
- What you are trying to prevent, what each level of testing is responsible for, what you have decided not to test, and how you will know the strategy is failing. A page is enough; anything longer stops being read.
- How do I decide what to test?
- By risk — likelihood of failure multiplied by cost of failure. Testing is a cost paid to reduce risk, and the parts of a system where failure is cheap and recoverable deserve less of it than the parts where it is not.
- Is it acceptable to decide not to test something?
- Yes, and it is the part most teams skip. Every team has untested areas; the difference is whether they are chosen deliberately and written down, or discovered during an incident.
Runnable samples for this page
last test results ↗- TypeScript
typescript/src/roles/test-strategy
Working tests, not fragments — they run in CI on every push to 8exgh/endtoendtester-samples.
Was this page useful?
Related topics
- SDET vs Automation Tester vs Manual QAThree genuinely different jobs that are routinely advertised as seniority levels of one — what each actually does, and what goes wrong when the distinction is lost.
- Quality OwnershipWhen a defect reaches production, whose failure is it? The answers that feel good, the one that works, and the practices that make it real.
- The Testing PyramidWhy cheap tests must outnumber expensive ones, what the pyramid actually claims, the trophy and honeycomb alternatives, and how to tell which shape you really have.
- Flaky TestsWhy tests fail intermittently, the six root causes and how to fix each one, how to detect flakiness deliberately, and what to do with a test you cannot fix today.
- Code CoverageWhat the percentage measures, why it is a finding tool rather than a target, how to collect it in each ecosystem, and how to gate on it without causing harm.