SoftwareTestPilot
Topic 15 of 100

Exploratory Testing — Definition, Charters & Session-Based Practice

Exploratory testing is what finds the bugs scripted tests were never designed to catch. Done well, it is the most systematic form of QA in the toolbox; done poorly, it is expensive clicking.

Last updated: June 2026

Section 1

Executive Definition

Exploratory testing is simultaneous learning, test design, and test execution. A tester approaches a product without a pre-written script, forms hypotheses about how it might break, and pursues those hypotheses interactively. The results of each action inform the next. Cem Kaner coined the term in 1984; James Bach and Michael Bolton later formalised it into session-based test management, which is the pragmatic form most teams practise today.

The word 'exploratory' misleads people into thinking the discipline is unstructured. It is not. A session-based exploratory test has a chartered mission ('investigate refund flow behaviour under partial-payment scenarios'), a timebox (typically 60 to 90 minutes), and a written debrief afterwards. The tester documents what was tested, what was found, and what remains unexplored. Over a sprint those debriefs become a living map of the product's risk surface.

Exploratory testing exists to cover the space that scripted testing cannot. Scripted tests answer 'does the system still do what we specified?'; exploratory tests answer 'what does the system actually do that we did not think to specify?'. Both are needed. Automation catches regressions on known behaviour; exploration surfaces the unknown behaviours that will become regressions if left uncovered.

The tester's mental toolkit is a set of heuristics — CRUD, boundary, feature interaction, resource exhaustion, session hijack, back-button, offline, timezone. Heuristics generate hypotheses ('what happens if I refund an order that was itself created from a refund?'). Each hypothesis becomes a small experiment. Findings feed a bug report or a new scripted test. This loop, run inside a timebox, is what separates exploration from random clicking.

Exploratory testing scales through infrastructure and culture, not by cloning testers. Infrastructure: shared charter backlog, session note templates, screen-recording tools (Loom, TestBuddy), a bug tracker that accepts video attachments. Culture: sessions treated as first-class deliverables in the sprint, debriefs presented at retro, and time explicitly protected in every release cycle. Teams that skip the infrastructure end up with exploratory tests that are neither reproducible nor sharable, which is the same as not having done them.

Section 2

Architecture & Production Code

Session-based test management, or SBTM, gives exploratory testing its scaffolding. The tester works inside a session that has a charter, a duration, and a debrief.

┌────────────────────┐
│ Charter backlog    │
│  - refund edge     │
│  - locale switching│
│  - session expiry  │
└─────────┬──────────┘
          │ pick
          ▼
┌────────────────────┐
│ Session (60–90 min)│
│  charter           │
│  timebox           │
│  tester            │
└─────────┬──────────┘
          │ during
          ▼
┌────────────────────┐        ┌────────────────────┐
│ Explore & log      │ ──────▶│ Bugs / questions   │
│  hypotheses, notes │        │ new charters       │
└─────────┬──────────┘        └────────────────────┘
          │ after
          ▼
┌────────────────────┐
│ Debrief with lead  │
│  coverage summary  │
│  risks surfaced    │
│  follow-up actions │
└────────────────────┘

The charter is the contract. A good charter is a single sentence with a mission, a target area, and any specific risks or tools to use — 'Explore refund creation using PayPal wallets, focusing on partial refunds and currency mismatch'. Vague charters ('test the checkout page') waste the session.

The timebox forces prioritisation. Ninety minutes is short enough to sustain concentration and long enough to build context. Sessions longer than two hours produce diminishing returns; sessions shorter than 45 minutes are all setup and no exploration.

The debrief is where the value lands. Without it, findings live in one tester's head and never make it into automation, documentation, or design conversations. Aim for a 15-minute debrief per session, using the PROOF template (Past, Results, Obstacles, Outlook, Feelings) or an equivalent structure.

markdown
session-notes/2026-06-refund-edge.md
# Charter
Explore refund creation for PayPal wallet payments, focusing on
partial refunds, currency mismatch, and refunds of refunds.

# Session
- Tester: Priyanka G.
- Date: 2026-06-14
- Duration: 90 minutes
- Environment: staging.example.com build 4.12.3

# Test notes
- Created order o_1001 (USD 120.00, PayPal EUR wallet).
- Full refund: OK, PayPal reference returned within 1200ms.
- Partial refund 60.00: OK, but confirmation email says "USD 60"
  while UI shows "€ 55.34". [BUG-2411]
- Refund of a refund attempted via API PATCH /refunds/{id}/refund.
  Server returned 200 with empty body. UI shows the child refund
  but no ledger entry. [BUG-2412]
- Currency mismatch: order in USD, PayPal wallet in JPY.
  Rounding drifts by 1 JPY on partial refunds > 5 iterations. [Q]

# Coverage
- ✓ Partial refunds (single, multi-line)
- ✓ Full refunds
- ✓ Refund-of-refund
- ✗ Refunds after 180 days (charter for next session)

# Risks surfaced
- Email localisation is inconsistent with UI currency display.
- Refund-of-refund is under-specified in the API contract.

# Follow-up
- File BUG-2411, BUG-2412.
- Add contract test for /refunds/{id}/refund response body.
- New charter: refunds after 180-day window.
Section 3

Exploratory vs Scripted vs Ad-Hoc Testing

AspectExploratory (SBTM)Scripted manualAd-hoc clicking
PreparationCharter, tools, notes templateDetailed step listNone
StructureTimeboxed session + debriefPredefined stepsNone
ReproducibilityHigh (notes + recording)High (steps)Low
Bug-finding powerVery high on unknownsMedium (specified behaviour only)Random
Best forNew features, complex flowsRegression, audit trail5-minute smoke by a dev
Common misuseDebrief skippedSame script for 3 yearsCalled 'exploratory'

Ad-hoc testing is not exploratory testing. The difference is the charter, the timebox, and the debrief. Without those three, the activity is just clicking, and it will not compound into knowledge or automation.

Section 4

Production Debugging Scenarios

Exploratory practices break down predictably when a team scales them without the supporting rituals.

Scenario 1

Findings never become automation

Symptom
The same bug is rediscovered in every release by manual exploration.
Root cause
Debriefs do not close the loop by filing an automation ticket.
Fix
Add 'automation candidate: yes/no' to the debrief template. Route yes candidates to the SDET backlog by end of session.
Scenario 2

Charters drift into 'test everything'

Symptom
Sessions last 3 hours and produce shallow coverage of many areas.
Root cause
The charter was written by the tester on the fly, not scoped in planning.
Fix
Draft charters during sprint planning. Cap each at 90 minutes and one focus area. Split rather than stretch.
Scenario 3

Notes are illegible after the session

Symptom
The tester cannot reconstruct what happened, so bugs cannot be filed with reproduction steps.
Root cause
Notes were shorthand fragments without timestamps or screenshots.
Fix
Adopt a template with timestamped entries, always record the screen, and attach short clips to bug reports.

Practice this concept in a real QA interview

Run a live mock with our AI Interview Coach, tune your resume with the ATS Resume Reviewer, and screen live listings on the QA Jobs Radar.

People Also Ask

1.What is exploratory testing?
Simultaneous learning, test design, and execution — a tester investigates the product interactively, guided by heuristics and a chartered mission.
2.How is exploratory testing different from ad-hoc testing?
Exploratory has a charter, a timebox, and a debrief; ad-hoc has none of those. Ad-hoc is unstructured clicking, not exploration.
3.What is session-based test management?
A structured practice, formalised by James Bach and Jonathan Bach, where exploratory testing is done in charter-driven, timeboxed sessions with written debriefs.
4.Can exploratory testing be automated?
No — automation eliminates the learning loop that defines exploration. But exploration frequently produces automation candidates.
5.How long should a session be?
60 to 90 minutes. Shorter sessions are dominated by setup; longer sessions produce diminishing returns.
6.Who writes charters?
Usually the QA lead or SDET during sprint planning, informed by risk analysis and recent bug patterns.
7.Does exploratory testing replace scripted regression?
No — the two are complements. Scripted regression protects known behaviour; exploration surfaces unknown behaviours.
8.What tools help with exploratory testing?
Screen recorders (Loom, TestBuddy), note templates (Markdown, Notion), and bug trackers that accept video attachments.
9.Is exploratory testing still relevant with AI?
More than ever — AI generates many scripted checks but cannot form novel hypotheses about a product it has never used.