Blog
Test Charter: What it is and How to Write One

Adwitiya Pandey
Published on

Table of contents
Lorem ipsum
Lorem ipsum
Lorem ipsum
Lorem ipsum
Lorem ipsum
A test charter is a short, focused mission statement that guides an exploratory testing session. It names what will be tested, what resources will be used, what information the tester is trying to discover, and how long the session will last. The charter is the hypothesis the session sets out to investigate, the session is the investigation, and the debrief is the finding.
This guide covers where the charter came from, the anatomy of one that produces useful sessions, the six charter types most teams need, a step-by-step method for writing them, worked examples from realistic enterprise scenarios, the session structure that turns a charter into a finding, and why the AI-coded era has made this kind of exploration more valuable rather than less.
A Scene That Plays Out Every Week
A tester is told to spend a few hours exploring the new release and let the team know what they find. The tester opens the application, clicks around, takes some notes, reports a handful of observations that nobody acts on, and the day ends.
Same tester, same application, different brief. Explore the new returning-customer checkout flow on the mobile site for ninety minutes, using last week's test data, looking specifically for issues that could affect loyalty-tier promotions. Three bugs in ninety minutes, two of them release-blocking.
The difference is not talent, it is intent, and the artefact that holds the intent is the charter. Everything else on this page follows from that single observation, that exploration with a direction finds what exploration without one misses.
What is a Test Charter?
A test charter is a short written brief for an exploratory testing session, usually one to three sentences long. It answers four questions:
What are you exploring?
What will you use?
What are you trying to find out?
How long will you spend?
Think of it as the smallest possible plan that turns someone clicking around into someone investigating something specific. It’s small, so it’s quick to write. It’s a question you’re trying to answer, which makes exploratory testing more like an investigation than free play. And it keeps the tester focused, which is the whole point.
Where Test Charters Came From
Test charters are part of session-based test management (SBTM), which Jonathan and James Bach introduced in 2000. They were trying to fix a long-standing problem. Exploratory testing found bugs scripted testing missed, but it was hard to plan, hard to measure and hard to report on. Sessions were random, findings were anecdotal, and managers couldn’t see what was happening.
SBTM gave exploratory testing a structure: a charter to set the direction, a time-boxed session to do the work, and a debrief to capture what was found. That made it possible to plan and measure the work without taking away the creativity that makes exploratory testing useful.
Also read: our guide to ad hoc vs exploratory testing explains why structured exploration finds bugs that random clicking misses.
Test Charter vs Test Case vs Test Scenario
Test charters often get confused with test cases and test scenarios, but each one does a different job.
Test Charter | Test Scenario | Test Case | |
|---|---|---|---|
What it is | A brief for an exploratory session | A situation or workflow to check | Exact steps and expected results |
How detailed | One to three sentences | A sentence or short paragraph | Step by step |
Who decides the steps | The tester, during the session | The tester, when writing test cases | Whoever wrote the test case |
What you get from it | Bugs, risks, questions and ideas for more charters | One or more test cases | A pass or fail |
Best for | Finding things nobody thought to test | Making sure key workflows are covered | Checking known behaviour the same way every time |
Example | “Explore guest checkout with expired cards to find payment error handling issues in 60 minutes” | “A guest pays with an expired card” | “Enter card 4111…, expiry 01/20, click Pay, check the ‘Card expired’ message shows” |
Put simply, a test case tells the tester exactly what to do. A test scenario says what behaviour should be checked. A test charter tells the tester what to investigate and leaves the how to them. Teams that use all three tend to have much clearer testing than teams that rely on just one.
The Anatomy of a Good Test Charter
A useful charter carries four mandatory components and one optional one. None of the mandatory components is heavy, and none of them can be skipped.

The Target
What is being explored, meaning a specific feature, journey, area, integration point, or risk surface. The target should be narrow enough that the session can produce useful findings within the time-box, and broad enough that the tester has room to explore.
The Resources
What the tester will use during the session, meaning test data, accounts, environments, tools, browsers, or devices. A charter that lists no resources tends to produce sessions that stall while the tester hunts for working data or a stable environment.
The Information Goal
What the session is trying to discover, which is what separates a charter from a vague brief.
"Look for bugs" is not an information goal, whereas "identify issues affecting the returning-customer flow under loyalty-tier conditions" is, and the specificity of the information goal is the strongest single predictor of session productivity.
The Time-Box
How long the session will run, typically between sixty and one hundred and twenty minutes. The time-box is not a deadline for finishing exploration, it is a deadline for the current session, and multiple sessions on the same area are normal and often valuable.
Risks to Probe
What the tester suspects might be wrong, or what would be most damaging if wrong. The risk hint points the tester at likely-fertile ground without prescribing what to do, and charters with risk hints tend to produce findings faster, while charters without them remain valid for genuinely open exploration.
The Bach pattern compresses the components into a single sentence, namely "Explore [target] with [resources] to discover [information goal] in [time-box]."
A charter for a banking application might read, "Explore the new returning-customer mobile checkout flow with the loyalty-tier test accounts to discover issues affecting promo eligibility within ninety minutes." The sentence carries the target, the resources, the information goal, and the time-box, so the tester reading it knows what to focus on, what to work with, what to look for, and how long to look.
The Six Charter Types
Six Types of Test Charter
Different sessions have different goals. These six types cover almost everything most teams need.
Type | What It’s For | When to Use It | What You Usually Get |
|---|---|---|---|
Survey | Getting to know a new or changed area | Before deeper testing | A map of the area and ideas for more charters |
Deep dive | Exploring one small area in detail | After a survey | The most surprising bugs, because the tester knows what “normal” looks like |
Bug hunting | Looking for a problem you already suspect | After a customer report, support ticket or developer hunch | A confirmed bug, or confirmation there isn’t one |
Risk-based | Focusing on a known risk, whether technical, business or customer | New integrations, regulated features, journeys customers complain about | Findings on the riskiest area |
Feature | Exploring a new feature before it’s signed off | During the sprint it’s built | Issues acceptance tests wouldn’t catch, especially how it works with existing features |
Regression | Exploring an area after a big change | After a release or major refactor | Unexpected changes your automated tests didn’t predict |
Most teams use all six over a year, often without naming them. Knowing which type you’re running helps you write the charter, plan the resources and know what to expect.
How to Write a Test Charter, a Step-by-Step Method
Six steps capture the working discipline.

Identify the Area to Explore
Begin by naming the target. The area should be narrow enough to be exploreable within the time-box and broad enough to deserve a dedicated session, so whole applications are too broad and single fields are too narrow, while features, journeys, integrations, and sub-flows are about right.
A useful heuristic is that if the area can be described in five to fifteen words it is probably scoped well, and if it takes a paragraph it is probably too broad.
Articulate the Information Goal
State what the session is trying to discover, in language a stakeholder would understand. The information goal is the question the charter is asking, and specificity matters more than length, so "issues affecting promo eligibility in the returning-customer flow" is better than "any bugs in the checkout," because the first directs attention and the second invites everything and surfaces nothing. If multiple information goals seem to apply, prefer the one that addresses the highest-stakes risk in the available time, since a charter that chases three goals usually achieves none.
Name the Resources
List what the tester will use, including test accounts, test data, environments, tools, browsers, devices, and supporting documentation.
Resources that need preparation should be flagged before the session begins, because sessions that start without prepared resources usually end without findings.
A practical check is to ask whether a tester who knew nothing about the project could begin the session given just the charter and the listed resources, and if the answer is no, the resources list is incomplete.
Set the Time-Box
Choose a session length. Sessions shorter than forty-five minutes rarely produce substantive findings, since the tester is still warming up when the session ends, and sessions longer than one hundred and twenty minutes start to lose focus as the tester drifts into wandering, so the Bach-recommended range of sixty to one hundred and twenty minutes accommodates most useful sessions.
The time-box is a deadline for the session rather than for the exploration, and areas worth deeper investigation can have multiple sessions, with many of the most productive programmes running a series of chartered sessions on the same area across a release.
Note the Risks to Probe
If specific concerns are known, note them as hints, keeping them light, a phrase or two pointing the tester at likely-fertile ground without telling them what to do.
A risk-hinted charter for the same checkout flow might add "particularly the interaction between the new loyalty-tier discount and the existing volume-discount stacking rules."
The tester can follow the hint or deviate, since the hint exists to help rather than to constrain.
Review With a Peer Before Starting
A two-minute conversation with another tester or with the product owner before the session begins is the most underused practice in chartered testing.
The conversation surfaces ambiguities, such as whether "loyalty tier" means the new five-tier scheme or the legacy three-tier one, gaps, such as whether the post-checkout email confirmation should be in scope, and resource needs, such as diagnostic-mode access.
The review takes less time than discovering the same gaps mid-session, and teams that review charters routinely report meaningfully more productive sessions than teams that draft and execute in isolation.
Test Charter Examples From Enterprise Practice
Abstract descriptions of any technique only go so far, so the charters below are drawn from realistic industry archetypes and span different charter types.
Example 1 - A Survey Charter for a Telecoms Self-Service Portal
"Explore the customer self-service portal's new bill-payment flow with a sample of mid-tier postpaid accounts to map all user paths through the payment journey, including failure and recovery paths, within ninety minutes."
The target is the new bill-payment flow, the resources are mid-tier postpaid test accounts, the information goal is a map of user paths including failure and recovery, and the time-box is ninety minutes.
The charter is a survey, run before more focused exploration, and its purpose is orientation rather than defect finding, so the output will likely be a path diagram and a list of follow-up charters for deep-dive sessions.
Example 2 - A Bug-Hunting Charter for a Life Insurer's Premium Calculator
"Explore the new annual premium calculator with the regulatory test scenarios for whole-of-life and unit-linked policies, looking for premium values that deviate from the legacy system by more than the agreed tolerance, within sixty minutes."
The target is the new premium calculator, the resources are the regulatory test scenarios for two policy types, the information goal is premium values deviating from legacy by more than the agreed tolerance, and the time-box is sixty minutes.
The charter is bug-hunting with a clear definition of what counts as a finding, and the narrow information goal makes the session highly focused, so a deviation would be a finding while the absence of deviations is itself a result worth recording.
Example 3 - A Regression Charter for a Logistics Platform After a Refactor
"Explore the cross-border shipment booking flow after the routing-engine refactor, with test data covering the five most common origin-destination pairs and three vehicle types, looking for behaviour changes versus the pre-refactor baseline, within one hundred and twenty minutes."
The target is the cross-border booking flow, the resources are test data for five origin-destination pairs and three vehicle types, the information goal is behaviour changes versus the pre-refactor baseline, and the time-box is one hundred and twenty minutes.
The charter is regression-oriented with the baseline explicitly named as the reference point, so the tester is not looking for defects in absolute terms but for differences from the known-good prior behaviour, and the output should be a list of observed differences, each annotated as expected or unexpected.
Example 4 - A Feature Charter for a Healthcare Scheduling Module
"Explore the new clinician availability-scheduling feature with two test clinics configured for overlapping shift patterns, to discover issues in how the feature handles double-booking and cancellation, within ninety minutes, particularly where a cancelled appointment should release a held slot."
The target is the new scheduling feature, the resources are two configured test clinics, the information goal is double-booking and cancellation handling, and the time-box is ninety minutes, with a risk hint pointing at slot-release behaviour. The charter is a feature charter run before formal acceptance, aimed at the interactions the acceptance tests are least likely to cover.
These four span survey, bug-hunting, regression, and feature charters across four industry archetypes, each focused enough to produce findings in the available time and each open enough for the tester's judgement to operate.
How to Run a Test Session
A charter on its own is just a document. A session without a debrief only helps the person who ran it. A full session has three parts.
Stage | How Long | What Happens |
|---|---|---|
Setup | 5 to 10 minutes | Read the charter, check the resources work, start the timer, get ready to take notes |
Exploration | Most of the session | Test the target against the goal, noting bugs, risks, questions and areas to look at later |
Debrief | 10 to 15 minutes | Write up what was explored, what was found, what was put off and what to explore next |
On-Charter and Off-Charter Testing
During the session, you’re free to follow anything interesting that comes up, even if it wasn’t in the charter, as long as you note it down. SBTM calls these on-charter testing (what the charter asked for) and on-opportunity testing (useful things you spotted along the way).
Good teams roughly track the split. If sessions keep drifting off-charter, it can mean your charters are aimed in the wrong place, and the real risks are somewhere else.
Using PROOF for the Debrief
SBTM uses the acronym PROOF to structure the debrief conversation:
Letter | Stands For | Question to Ask |
|---|---|---|
P | Past | What happened during the session? |
R | Results | What did you find or achieve? |
O | Obstacles | What got in the way of good testing? |
O | Outlook | What still needs to be done? |
F | Feelings | How do you feel about this area? |
These five questions turn “how did it go?” into a proper handover a test manager can act on. The last one matters more than it looks. A tester’s gut feeling that something’s off often points to the next charter worth writing.
The Session Report
The debrief produces a session report, sometimes called a session sheet. It’s the lasting record of what happened.
Before session reports, if a manager asked an exploratory tester what they’d done, the answer was often “I looked around and found a few things”, which nobody could plan around.
A consistent report changes that. You can count sessions per area, see how time splits between testing, bug investigation and setup, and check which important areas have been covered.
That’s what lets exploratory testing sit properly alongside scripted testing.
Building a Charter Library
A charter that worked once is often worth running again. Treating charters as reusable, not throwaway, is how a team’s exploratory testing gets better over time.
A survey of a payment flow can be rerun after the next release, with fresh data, to catch regressions.
A bug-hunting charter that found a bug can be rerun to confirm the fix and make sure it doesn’t come back.
A feature charter can become a regression charter once the feature is established.
Keep your charters in a library, tagged by area, type and risk. Then you can size, prioritise and assign them like any other work.
Run charters first for the areas where a failure would hurt most: key customer journeys, recently changed code, regulated features and areas with a history of bugs or complaints.
Test Charters in Agile and Continuous Delivery
Agile and continuous delivery haven’t made charters obsolete. They’ve just changed when you run them.
When | Charter Type | Why |
|---|---|---|
During the sprint | Feature | Find issues in new features before they’re closed |
After a big change or release | Regression | Catch the unexpected things automated tests can’t predict |
Regularly, like once a week | Risk-based or deep dive | Catch slow drift and hidden interactions in your most important areas |
Charters don’t need a release to happen. You just need an area worth exploring and a time-box. So teams shipping several times a day still run them, usually tied to higher-risk deployments or changes to key customer journeys.
In Brian Marick’s agile testing quadrants, exploratory testing sits in Q3, the business-facing quadrant that critiques the product. Charters are how teams actually do Q3 work. Teams that focus heavily on automated unit and acceptance tests (Q1 and Q2) often end up with a thin Q3, and charters are how you build it back up.
Charters work best alongside a solid automated regression suite. To see how Virtuoso QA keeps regression running on every release so testers have time to explore, take a look at regression testing.
Common Test Charter Mistakes
Mistake | What Happens | What to Do Instead |
|---|---|---|
Too broad | “Explore the application” leads to scattered notes and no real findings | Narrow the target before you start |
Too narrow | A charter with specific steps is really a test case, and you lose the discovery | Say what, with what and to find what, but leave the how to the tester |
No clear goal | “Look for bugs” finds the obvious stuff and misses the subtle | Write a specific information goal |
No time-box | The session drifts and focus fades | Set a time limit, even a short one |
No debrief | What the tester found disappears with their memory | Spend at least ten minutes writing it up |
Using charters once | Each one is thrown away, and the team keeps relearning the same things | Keep a charter library and rerun the good ones |
Why Test Charters Matter More with AI-Written Code
AI-assisted development has made exploratory testing more important, for three reasons:
AI Handles More of the Routine Testing
AI now writes a lot of unit and acceptance tests. That leaves testers more room for the exploratory work that still needs human judgement.
AI Written Code Has More Surprises
AI writes behaviour nobody designed on purpose. Exploring is the best way to find those surprises before customers do.
What Matters is the Customer Journey
Customers care whether checkout, claims or bookings work, not whether each function passes. Charters aimed at key journeys catch behaviour changes automation can miss.
So the practical approach is to let automation carry the regression load, and point charters at new features, big changes and key journeys under unusual conditions.
Where Virtuoso QA Fits
Virtuoso QA doesn’t write charters. Deciding where to look is a human judgement call. What it does is take repetitive regression work off your testers, so they have more time for chartered sessions.
Regression that looks after itself: tests are written in plain English based on what a journey should do, so testers don’t spend charter time fixing broken scripts.
Fixes you approve: when a screen changes, Virtuoso QA suggests a fix for your team to accept or reject, instead of the test just failing.
Wide browser coverage: the same tests run across 2,000+ browser and OS combinations, so you don’t need exploratory sessions just to check the basics on each browser.
Bugs from sessions become tests: when a session finds a bug, a tester can write the regression test for it in plain English straight away, so it’s checked on every release after that.
To see how AI takes repetitive test work off your team while they stay in control, take a look at Virtuoso QA’s AI-powered test automation.
Frequently Asked Questions
What Are the Key Components of a Test Charter?
What Is the Bach Format for a Test Charter?
How Long Should a Test Charter Session Be?
What Is On-Charter Versus On-Opportunity Testing?
Are Test Charters Only for Manual Testing?
Why Are Test Charters Important in AI-Coded Software?
Written by

Adwitiya Pandey
Senior Test Evangelist
Adwitiya works directly with QA teams adopting the platform and turns what he sees into practical guides on test design, regression strategy and keeping coverage honest.










