Skip to content
Tutorials Center
My learning

Topics

Lesson 34 of 60 ยท Defects and Test Execution

Exploratory Testing in Practice

Run a real exploratory testing session: write a charter, time-box it, take notes, use SFDIPOT and CRUD heuristics, and debrief. Includes a session log analyser.

Exploratory testing means designing and running tests at the same time, using what you learn from each step to choose the next one. It is not random clicking. A good exploratory session has a goal, a time limit, notes and a debrief, and it often finds the bugs that carefully scripted cases miss, because the tester reacts to what the software actually does.

The ideas behind it are introduced in Experience-Based Testing. This lesson is the practical side: how to organize a session so that it is repeatable, reviewable and useful to the team. If you want the reason scripted tests alone are never enough, revisit the pesticide paradox in The Seven Testing Principles.

One exploratory session

Charter A short mission for the session.
Time-box Usually 45 to 120 minutes.
Notes Record ideas, bugs and questions.
Debrief Share findings within a day.
1 / 2

Styles of exploratory testing

Exploratory testing comes in a few flavors, and teams often mix them:

  • Freestyle: no charter, no structure; an experienced tester simply explores. It suits quick smoke checks of a new build, or a first look at an unfamiliar product.
  • Scenario-based: the tester starts from user scenarios or stories and explores variations around them (a different order of steps, a different user role, interrupted flows).
  • Strategy-based: the tester applies a known technique such as boundary analysis, error guessing or the heuristics below while exploring, so exploration still follows a plan.

Advantages: it encourages creativity, finds bugs that scripted tests miss, needs little preparation, adapts immediately when the product changes, and gives fast feedback early in a project. Limitations: results depend on the tester's skill, coverage is hard to measure and repeat, and it is difficult to estimate. Charters, time-boxes and notes (covered below) address most of these weaknesses.

Scripted versus exploratory

Scripted testing writes cases first and executes them later. Exploratory testing interleaves learning, test design and execution in one loop. Neither is better in general; they answer different questions.

Scripted Exploratory
Best for Known requirements, regression, audits New features, unclear areas, finding surprises
Preparation Cases written and reviewed A charter and a few ideas
Variation Same steps every run Different every session
Evidence Pass/fail per case Notes, bugs, coverage observations

Mature teams use both. Scripted checks protect old behavior; exploration hunts for what nobody thought of.

Charters

A charter is a one-sentence mission that gives a session direction without dictating steps. A popular template is:

Explore target with resources or approach to discover information.

Examples:

  • Explore the coupon box in checkout with odd inputs to discover validation problems.
  • Explore the profile photo upload with large and corrupted files to discover how errors are reported.
  • Explore the new search filters with a screen reader to discover accessibility barriers.

A good charter is narrow enough to finish in one session and broad enough to allow choices. "Test the website" is too broad. "Click the blue button on the About page" is a script, not a charter.

Time-boxing

Session-based test management uses time-boxes of roughly 60 to 90 minutes: long enough to get deep, short enough to stay focused and be reviewed. Interruptions are logged rather than hidden. Some teams use shorter boxes (30 minutes) for quick checks, or two testers in a pair, which often finds more because the partner asks "why did you try that?".

When the box ends, stop and write up, even if you are in the middle of a promising idea. Note the idea as a follow-up charter.

Taking notes

Notes are what turn exploration into evidence. Write while you work, in short timestamped lines, and tag each line so that it can be analysed later. A common set of tags:

  • TEST: what you tried
  • BUG: a defect you found (a full report comes later)
  • QUESTION: something the requirements or team must answer
  • ISSUE: anything that blocked you, such as an outage or missing test data
  • SETUP: preparation time, accounts, data

Also capture what you observed, not only what you did: screenshots, copied error messages, request and response samples. A bug without a trail is hard to reproduce, as covered in Writing Excellent Bug Reports.

Analysing a session log

Teams that use session-based testing look at simple numbers per session: how the time was split, how many bugs were found and how fast. The stand-in below holds one invented session log and calculates those numbers. It is just a script; in real life the notes would live in a document or a tool.

JS Session log analyser

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

No output.

The "test design and execution" share (79% here) is a useful health check: if most of a session goes to setup and blocked time, the real problem is the environment, not the product. The bug rate says little on its own, since a session that finds nothing in a solid area is still valuable information. Be careful not to turn these numbers into targets.

Heuristics: where to look next

A heuristic is a rule of thumb that suggests ideas but never guarantees an answer. When you run out of ideas, a heuristic restarts the thinking. Two that are easy to remember:

SFDIPOT (often pronounced "San Francisco Depot") is a list of product aspects to examine:

  • Structure: what the product is made of
  • Function: what it does
  • Data: what goes in, comes out and is stored
  • Interfaces: how it connects to users and other systems
  • Platform: what it runs on
  • Operations: how people actually use it, including unusual paths
  • Time: timing, ordering, expiry and concurrency

CRUD reminds you that data usually has a life: Create, Read, Update, Delete. For any thing the product stores, try every operation, then try them in a strange order, twice, or with nothing there.

The stand-in prints both heuristics as a question list for a feature you name. The point is not the code; it is seeing how a one-word feature becomes eleven test ideas.

JS Turn a feature into test ideas

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

No output.

Change feature to something else, such as "password reset email", and the same questions apply.

Other useful heuristics include tours (walk the product as a first-time user, a data-heavy user or a "saboteur"), boundaries (see Boundary Value Analysis), and consistency checks ("does it behave like the rest of the product, the documentation, and similar products?").

The debrief

After each session, spend 10 to 15 minutes with a teammate or lead. The classic agenda is PROOF:

  • Past: what happened during the session?
  • Results: what was found and what was covered?
  • Obstacles: what slowed or blocked the work?
  • Outlook: what still needs testing? Which new charters follow?
  • Feelings: how confident are you about this area?

The debrief is what makes exploratory testing accountable. A manager reading "three bugs, two open questions, coverage of coupon validation but not of expiry, confidence low" understands the state of the area without watching you work.

Practical tips

  • Reproduce a bug right away and note the exact steps while they are fresh.
  • Vary one thing at a time when you chase a failure, so you know what caused it.
  • Keep a list of "I should come back to this". Follow-ups become the next charters.
  • Do not explore blindly on a fragile environment; check the setup first.
  • Use scripted and exploratory approaches together: when exploration finds a serious bug, add a regression check for it.

Check your understanding

Quick check ยท 5 questions

of 5 answered You scored / 5 ยท perfect!

  1. 1. What is the main difference between exploratory and scripted testing?

    In exploratory testing the tester designs the next test from what the last one revealed. It is structured, with charters, notes and debriefs, not random.
  2. 2. Which is the best charter?

    A good charter names a target, an approach and the information wanted. It is narrow enough for one session, yet leaves room for choices.
  3. 3. Which letter group of SFDIPOT would make you test what happens when a coupon expires at midnight?

    Time covers expiry, ordering, timing and concurrency. Midnight expiry is a classic time-related case.
  4. 4. In a session debrief, which question belongs to the O (Obstacles) of PROOF?

    Obstacles are anything that got in the way of testing, for example a down environment or missing data. Outlook is what comes next.
  5. 5. A session spent 60% of its time waiting for a broken test server. What does the session log most clearly tell you?

    Tracking blocked time exposes environment issues. It says little about the product's quality or the tester's skill.

Summary

  • Exploratory testing combines learning, test design and execution; it is disciplined, not random.
  • A charter gives each session a target, an approach and the information you want.
  • Time-box sessions (about 60 to 90 minutes) and tag notes as TEST, BUG, QUESTION, ISSUE and SETUP.
  • Heuristics such as SFDIPOT and CRUD generate ideas when you run dry.
  • A short debrief (PROOF) turns private exploration into shared, reviewable evidence.
  • Use exploration alongside scripted checks, and turn serious finds into regression tests.

Next up: Web UI, Usability and Accessibility Checks.