Exploratory testing has an image problem. To a manager who signs off releases, “the tester explored the app for two days” sounds like nothing was planned and nothing can be checked. To a good tester, exploration is where the most interesting bugs come from, because the next test is designed using what the last one revealed. Both views are reasonable. Session-based test management (SBTM), described by Jonathan and James Bach around 2000, exists to reconcile them. It keeps the freedom of exploration but wraps it in just enough structure that the work can be planned, measured and reviewed.

The structure has three parts: a charter that states the mission, a session that limits the time, and a debrief that turns what happened into shared knowledge. Each one solves a specific weakness of unstructured exploration.

The charter: a mission, not a script

A test script tells you what to click and what to expect. A charter tells you what to investigate and why, and leaves the how to you. Elisabeth Hendrickson’s book Explore It! offers a simple template: explore a target, with certain resources, to discover certain information.

Consider a payments team building UPI collect requests into a billing app. Three possible charters:

  • Explore the collect-request expiry flow with a device clock set ahead and behind IST, to discover how the app handles requests that expire while the user is mid-approval.
  • Explore the refund screen with accounts that have partial refunds already applied, to discover whether totals and balances stay consistent.
  • Explore payment status updates with throttled and dropped network connections, to discover what the user sees when the bank callback arrives late.

Notice what these do not contain: steps. They point attention at a risk. A charter that is too broad (“explore payments”) gives no focus and cannot be finished. One that is too narrow (“verify the amount field rejects letters”) is really a scripted check. The useful size is something a tester can meaningfully cover in one session.

Where do charters come from? Risk lists, recent production incidents, new features, areas with lots of recent code churn, customer complaints, and observations from earlier sessions. That last source matters: a good session often ends with two or three new charters for things the tester noticed but did not have time to chase.

The session: protected, uninterrupted time

A session is a block of uninterrupted testing against one charter, commonly around 90 minutes, though teams often allow short (about 60 minutes) and long (about 120 minutes) variants. The timebox does two things. It forces the tester to focus rather than drift between half-finished ideas, and it creates a countable unit. “We ran 14 sessions on the refund module this sprint” is a statement a release manager can work with in a way that “we explored refunds” is not.

Uninterrupted is the hard part in most Indian IT setups, where a tester may be pulled into a stand-up, a client call across time zones and a build issue in the same morning. A session that is broken into four pieces is not really a session. Teams that make SBTM work tend to protect session time explicitly, for example by blocking calendars and agreeing that chat can wait for 90 minutes.

During the session the tester keeps brief notes: what was tested, which data and configurations were used, questions that came up, bugs found, and issues (things that blocked or slowed testing but are not product bugs, such as a broken test environment). The notes are not a transcript. They need to be just good enough that someone else can understand what was covered and reproduce the interesting bits.

The session sheet and where the time went

The original SBTM approach asks testers to estimate how their session time was split across three activities, often called TBS:

  • Test design and execution: actually looking for problems.
  • Bug investigation and reporting: isolating and writing up what was found.
  • Session setup: preparing data, devices and environments.

These are rough percentages, not stopwatch readings, and their value is in the pattern. Suppose a team runs ten sessions on the refund module and the sheets show setup eating around half the time in most of them. That is not a tester problem. It says the test environment or test data is so hard to prepare that real testing is being starved. A manager reading only bug counts would never see this. Similarly, if bug investigation dominates, the area is probably buggy enough that more sessions are needed before anyone can say it has been covered.

Sheets also record the charter versus opportunity split: how much time stayed on the charter and how much went on worthwhile side paths. Some opportunity time is healthy. A lot of it suggests the charter was poorly chosen or that something more important surfaced.

The debrief: where the value is captured

After each session, or a small batch of them, the tester spends 10 to 20 minutes with a lead or peer. A widely used checklist for the conversation is PROOF:

  1. Past: what happened during the session?
  2. Results: what was achieved, and what was found?
  3. Obstacles: what got in the way?
  4. Outlook: what still needs to be done?
  5. Feelings: how does the tester feel about the product area?

The last item sounds soft but is not. Experienced testers often sense that an area is fragile before they can prove it. “I did not find anything, but every screen felt slow and the error messages were inconsistent, I do not trust this” is valuable input for a release decision, and the debrief is the place it gets said aloud.

Debriefs also make exploratory testing teachable. A senior tester listening to a junior’s debrief can ask “did you try it with an account that has no PAN linked?” and the junior learns a heuristic they will reuse for years. This is how good testing judgement spreads through a team without being written into a 200-page test plan.

Exploration alongside heavy automation

Teams with large automated regression suites sometimes ask whether exploration still has a place. The answer follows from what each does. Automated checks confirm that known expectations still hold. They are excellent at catching regressions in behaviour someone already thought to specify. Exploration looks for the problems nobody specified: odd interactions, confusing flows, risky assumptions. The two complement each other, and SBTM gives a way to point exploration at exactly the gaps automation leaves, such as new features before their checks exist, cross-feature interactions, and areas with recent incidents.

There is also a feedback loop. A bug found in a session that represents a stable expectation is a good candidate for a new automated check. Over time, exploration feeds the regression suite, and the regression suite frees testers to explore further.

Where SBTM goes wrong

The most common failure is turning sessions into a quota. If testers are judged on sessions per week or bugs per session, they will choose easy charters and inflate counts. The numbers are for understanding coverage and obstacles, not for ranking people. A second failure is skipping debriefs when the schedule tightens, which removes most of the learning and leaves only paperwork. A third is writing charters so detailed that they become scripts in disguise, which keeps the overhead of structure while losing the benefit of exploration.

Used well, SBTM lets a test lead say something precise before a release: these areas had this many sessions, these risks were investigated, here is what was found, here is what is still open and here is how confident the testers feel. That is a far stronger basis for a go or no-go call than a pass percentage on scripted cases alone.

Written by the RP Strativa Team. The payments team and charters in the examples are illustrative.

Leave a Reply

Trending