Exploratory and ad hoc testing
Exploratory testing (learning, designing, and running tests at the same time), plus session-based test management, how it differs from ad hoc testing, when each shines, and how to do it well with charters and notes.
Scripted testing is like following a recipe. Exploratory testing is like being a good cook who tastes as they go, notices the sauce is too thin, and adjusts on the spot. Both make dinner, but one of them can respond to surprises. There's a whole craft of testing that doesn't follow a pre-written script, and it catches the bugs scripts never thought to look for.
What exploratory testing actually is
Exploratory testing is doing three things at the same time: learning the software, designing tests, and running them, all in one flowing loop. You try something, watch what happens, and what you see shapes your very next move. It is not random clicking. It's a skilled, thinking activity where the tester's curiosity is the engine and each result steers the next test.
Imagine poking at a new file-upload feature. You upload a normal photo, and it's fine. That makes you wonder about a huge file, so you try a 2 GB one. It hangs, which makes you wonder about a tiny empty file, so you try that. Each discovery feeds the next idea. A script written a week ago could never have followed that trail, because it didn't know where the trail would lead.
Exploratory testing is simultaneous learning, test design, and test execution: the tester learns the product and designs the next test from what the last one just revealed.
Ad hoc vs. exploratory: a real distinction
People use these terms loosely, but there's a meaningful difference. Ad hoc testing is informal and unstructured: you just dive in and try things with no particular plan, often to get a quick feel for whether something is wildly broken. Exploratory testing is also unscripted, but it's structured and purposeful: you set a goal, take notes, and work methodically even though you're improvising the specific tests.
Think of it this way: ad hoc is wandering a city with no map for fun. Exploratory is wandering with a destination in mind, a notebook in hand, and a reason for each turn you take. Ad hoc is great for a quick gut-check; exploratory is a genuine, repeatable discipline.
Session-based test management
Exploratory testing's reputation problem is that it can feel unaccountable: what did you actually do for those two hours? Session-based test management (SBTM) fixes that by adding lightweight structure without killing the freedom:
- Charter: a short mission for the session, like "explore the coupon system, focusing on expiry and reuse limits." It points you without scripting you.
- Time-boxed session: a fixed block, often 60 to 90 minutes of focused testing, then a break to write up.
- Notes: you record what you tried, what you found, and any new questions, so the session leaves a trail others can follow.
- Debrief: a quick chat afterward about what you learned and what's worth exploring next.
Take notes as you go, not from memory afterward. In the heat of exploring you'll find three bugs in five minutes, and by the time you stop you'll have forgotten the exact steps for two of them. A running note is what turns a hunch into a reproducible bug report.
Scripted vs. exploratory: when each shines
Scripted testing
- Steps written in advance, run as written.
- Repeatable and easy to hand off or automate.
- Great for stable, must-not-break flows (login, checkout).
- Blind to anything nobody thought to script.
Exploratory testing
- Tests designed live, steered by what you find.
- Brilliant at uncovering the unexpected.
- Great for new, changing, or poorly-documented features.
- Harder to repeat exactly without good notes.
This isn't a contest with a winner. Mature teams use both: scripted (and automated) tests guard the critical paths that must never regress, while exploratory sessions go hunting in the corners where the surprising, embarrassing bugs hide. Lean only on scripts and you'll miss the weird ones; lean only on exploration and you'll forget to re-check the basics.
How to explore well
- Start with a charter so your curiosity has a direction.
- Follow your nose: when something feels off, chase it instead of snapping back to a plan.
- Vary one thing at a time so you can tell what actually triggered a problem.
- Think like a mischievous user: empty fields, the back button mid-flow, double-clicks, copy-paste, the wrong order.
- Write notes you could hand to a stranger: a discovery you can't reproduce isn't a finding yet.
- Exploratory testing is simultaneous learning, test design, and execution: each result shapes the next test.
- It is skilled and purposeful, not random clicking.
- Ad hoc testing is informal and plan-free; exploratory is unscripted but structured and goal-driven.
- Session-based test management adds charters, time-boxed sessions, notes, and debriefs to keep exploration accountable.
- Scripted tests guard the critical paths; exploratory testing hunts the unexpected. Strong teams use both.