Skip to content
Tutorials Center
My learning

Topics

Lesson 24 of 60 ยท Test Planning and Documentation

Test Strategy and Test Plan

Learn the difference between a test strategy and a test plan, what a plan contains (scope, approach, schedule, risks, entry and exit criteria) and write a one-page plan.

Good testing starts before the first test case. Somebody has to decide what will be tested and what will not, how, by whom, in which environment, by when, and how the team will know it is finished. If nobody decides, each tester decides alone, and the result is gaps, overlaps and a surprise at the end of the project.

Two documents carry those decisions. The test strategy describes the general approach to testing for an organization or a product, and lasts for years. The test plan applies that approach to one project or release: it is specific, dated and owned. This lesson explains what goes into each, what the old IEEE 829 standard contributed, and shows a one-page template with a small checker that reviews a plan for gaps.

Strategy versus plan

Strategy How we test, in general. Long-lived and shared.
Test plan What we test in this release, who, when.
Test cases The detailed steps and data.

Strategy guides plans; plans guide cases.

1 / 2

Strategy versus plan

A test strategy is the set of principles and choices that guide testing across projects. It answers questions that rarely change: which test levels do we use (see test levels)? Which types of testing matter for our kind of product (see test types)? What do we automate? How do we manage defects? What tools and environments do we use? In a small company it is a page or two; in a large one it is a policy document that every project inherits.

A test plan is created for a specific project, release or sprint. It takes the strategy and says: for this release, these features are in scope, these risks are highest, Maya and Dev will test, we have two weeks, and here is what must be true before we ship. A strategy tells you the rules of the game; a plan is the game plan for one match.

In an agile team, the same ideas exist in a lighter form. The strategy lives in the team's working agreements and definition of done; the "plan" for a sprint can be a short section in the sprint page or a one-page note. The names matter less than answering the questions.

Types of test strategy

Teams rarely pick one pure approach; they blend them. The common families are:

  • Analytical: testing is driven by analysis of requirements or risk. Risk-based testing (see risk-based testing) is the best-known example: you rank features by likelihood and impact and test the riskiest first.
  • Model-based: you build a model of the system, such as a state machine or a usage profile, and generate tests from it (see state transition testing).
  • Methodical: you follow a predefined checklist or standard set of tests, for example a fixed list of quality characteristics or a company's usability checklist.
  • Process-compliant (standards-based): you follow an external standard or regulation, such as an industry safety standard, and document accordingly.
  • Reactive (dynamic): you respond to the product as it is, with exploratory and experience-based testing (see exploratory testing), often combined with attack lists.
  • Consultative: testing scope is guided by advice from users, business experts or developers, such as "check these twenty configurations".
  • Regression-averse: the priority is protecting existing behavior, so you invest in automated regression suites and reuse them every release.

A strategy document also states its own limits. It is only as good as the information behind it, it can become stale if nobody updates it, and a rigid strategy can stop testers from reacting to surprises. Review it when the product, team or risks change.

What a test plan contains

The details change from company to company, but a good plan covers the same core topics.

Scope. List the features and quality attributes you will test (in scope) and, just as important, those you will not (out of scope), with a reason. Out-of-scope items are a disclosure, not an excuse: they tell stakeholders where they carry the risk. "Payment provider's own pages are out of scope because the provider tests them" is a good entry.

Approach. Describe how you will test: test levels, which techniques apply to which areas (boundary analysis for input fields, state transition testing for the order workflow, exploratory sessions for the new search), the automation plan, and the types of non-functional testing. Link to the strategy rather than repeating it.

Resources. People and their roles, the test environments, the test data (see test data and environments), devices and tools, and any training needed.

Schedule. Key dates: when the build arrives, when each cycle runs, when the defect-fix window closes, when the release decision is made. Tie the schedule to an effort estimate (see traceability and estimation) so that dates and capacity agree.

Risks. Product risks (the payment flow may charge twice) and project risks (the test environment will not be ready until week two), each with a likelihood, an impact and a response. Risk-based testing shows how risk drives priorities.

Entry and exit criteria. Entry criteria define when testing may start; exit criteria define when it may stop. They are the rules that prevent endless testing and premature release.

Entry and exit criteria

Entry criteria answer "is this build ready to be tested?" Typical items: the build is deployed to the test environment; smoke tests pass; test data is loaded; requirements are approved; test cases are reviewed. Without entry criteria, testers spend days on a build that does not even log in.

Exit criteria answer "are we done?" Good exit criteria are measurable. Compare these two:

  • Weak: "Testing is complete and quality is good."
  • Strong: "100 percent of high-priority test cases executed, at least 95 percent pass, no open critical or high-severity defects, every requirement covered by at least one passed test."

A related idea is suspension and resumption criteria: conditions under which testing pauses (for example, more than 20 percent of tests blocked by one defect) and when it restarts. Together, they make the decision to ship a matter of evidence rather than opinion. They do not remove the need for judgment: when a criterion is missed, the team may still choose to release, but it does so knowingly, with the risk written down.

The IEEE 829 idea

For decades the standard reference was IEEE 829, "Standard for Software and System Test Documentation". It defined a test plan outline with sections such as: test plan identifier, introduction, test items, features to be tested, features not to be tested, approach, item pass/fail criteria, suspension and resumption criteria, test deliverables, testing tasks, environmental needs, responsibilities, staffing and training, schedule, risks and contingencies, and approvals. It also defined documents for test design, test cases, procedures, logs, incident reports and summary reports.

IEEE 829 has since been replaced by the ISO/IEC/IEEE 29119 family of standards, which covers testing concepts, processes, documentation and techniques. You do not need to buy either to write a good plan. The enduring lesson of IEEE 829 is its checklist of topics: use it as a prompt to make sure nothing important is forgotten, and trim anything that does not help your project. A 40-page plan that nobody reads is worse than a one-page plan that everybody follows.

A one-page plan template

Here is a lightweight template you can copy. It is shown read-only because it is a document, not a program. Fill each line with concrete statements.

TEXT
TEST PLAN: <product> <release>                    Owner: <name>   Date: <date>

1. SCOPE
   In scope:      <features, quality attributes>
   Out of scope:  <items> (reason: <why>)

2. APPROACH
   Levels:        <unit / integration / system / acceptance and who owns each>
   Techniques:    <which technique for which area>
   Automation:    <what is automated, what is manual>
   Non-functional:<performance, security, compatibility checks planned>

3. RESOURCES
   People:        <names and roles>
   Environments:  <test, staging; data source; devices>
   Tools:         <defect tracker, test management, automation>

4. SCHEDULE
   <date> build ready | <date> cycle 1 | <date> cycle 2 | <date> release decision
   Estimated effort: <hours>   Capacity: <people x days x hours>

5. RISKS
   <risk> | likelihood | impact | response

6. ENTRY CRITERIA
   - <measurable condition>

7. EXIT CRITERIA
   - <measurable condition>

8. DELIVERABLES
   Test cases, execution results, defect reports, summary report
flowchart LR
  A["Strategy<br/>(general approach)"] --> B["Test plan<br/>(this release)"]
  B --> C["Test cases<br/>and data"]
  C --> D["Execution<br/>and results"]
  D --> E["Summary report<br/>against exit criteria"]
  E -.->|"lessons"| A

The documents form a loop: results feed back into the strategy.

A plan readiness checker

A plan is only useful if it is complete and consistent, and many of those checks are mechanical. The stand-in below represents a plan as data and reviews it against simple rules: scope has both in and out lists, exit criteria are measurable (they contain a number), every risk has a response, the schedule is valid, and the estimated effort fits the capacity. This is a teaching tool: a real review also needs human judgment about whether the content is sensible.

JS Reviewing a plan for gaps

Press Run (or Ctrl + Enter) to see the console output here.

No output.

The draft fails six of its nine checks: no out-of-scope list, a single entry criterion, two exit criteria that cannot be measured (two checks), a risk without a response, and an effort of 260 hours against a capacity of 180. The improved plan fixes each gap. Notice that capacity is simple arithmetic (testers x working days x productive hours per day), and that productive hours are fewer than paid hours because of meetings, setup and investigation.

Checking the exit criteria with data

At the end of a cycle, the exit criteria turn into a decision. The next stand-in encodes the criteria as small functions over the measured results and prints a verdict. The aim is to show that measurable criteria can be checked quickly and honestly.

JS Evaluating exit criteria against results

Press Run (or Ctrl + Enter) to see the console output here.

No output.

Cycle 1 fails four of the five criteria, so the plan says what happens next: fix, retest, and run another cycle. After cycle 2, the criteria are met. If a criterion were missed by a small margin on the deadline day, the plan would not forbid shipping; it would require that the product owner accept the risk explicitly. That explicit acceptance is what separates a managed risk from an ignored one.

Common mistakes

  • Copying an old plan without thinking. The template helps, but each release has its own risks and scope.
  • Leaving out the out-of-scope list. Stakeholders then assume everything is covered.
  • Vague criteria such as "good quality". If you cannot measure it, you cannot know when you reached it.
  • A plan written once and never updated. Plans change when the schedule, scope or risks change; keep the document current, or the team will stop trusting it.
  • A plan nobody owns. Name one person who maintains it and one who approves it.

The right length is the shortest document that makes the decisions visible. For a two-week sprint, that may be a single page; for a regulated medical device, it will be much longer and follow a formal standard.

Check your understanding

Quick check ยท 5 questions

of 5 answered You scored / 5 ยท perfect!

  1. 1. What is the main difference between a test strategy and a test plan?

    A strategy sets the general principles and choices; a plan is project-specific, with scope, people, dates and criteria.
  2. 2. Which exit criterion is best?

    A measurable criterion can be checked with data. The other options cannot be verified objectively.
  3. 3. Why should a test plan list items that are out of scope?

    An explicit out-of-scope list prevents wrong assumptions: it shows where the project carries untested risk.
  4. 4. Two testers have 10 working days at 6 productive hours per day. The estimate is 150 hours. What is the situation?

    Capacity = 2 testers x 10 days x 6 hours = 120 hours, which is less than the 150 hours estimated.
  5. 5. What happened to IEEE 829?

    IEEE 829 defined classic test documentation. The ISO/IEC/IEEE 29119 standards superseded it, yet its topic list remains a handy prompt.

Summary

  • A test strategy is the long-lived general approach; a test plan applies it to one project or release.
  • A plan covers scope (in and out), approach, resources, schedule, risks, and entry and exit criteria.
  • Exit criteria must be measurable; they turn the release decision into evidence-based judgment.
  • IEEE 829 gave the classic outline, now superseded by ISO/IEC/IEEE 29119; use the topics as a checklist, not a burden.
  • Keep the plan short, owned and current, and check that effort fits capacity.

Continue with Writing Good Test Cases.