Discover Additional Bugs Through Exploratory Testing

Identify the Purpose of Exploratory Testing

Exploratory testing lets you go beyond the test plan. It’s a software testing approach that involves informally exploring the system to identify problems and defects.

It is generally used as a complement to acceptance tests, which cover system features in a formal, structured way.

Exploratory tests are recommended in the following cases:

• when specifications are incomplete or inadequate;

• when time is severely limited:

  • It’s often faster to run a test directly than to read every step and verify manually.

• to complement more formal testing methods and uncover defects that structured approaches may miss.

Exploratory testing is the simultaneous act of learning, designing, and executing tests.

Unlike acceptance testing where test cases are designed before execution—exploratory testing is a learning phase. You discover the website as you test it.

Exploratory testing helps you:

• find defects missed by formal testing and make planned tests more efficient. With experience, you’ll learn to concentrate on the areas most likely to cause problems;

• identify unexpected issues: flexible exploration may reveal problems not discovered by planned tests;

• improve the site’s usability and stability;

• discover new ideas and features to add to the backlog;

• boost creativity: exploratory testing encourages varied approaches, leading to a wider range of tests and potentially more defects found;

• find requirement and design defects, since the tests aren’t constrained by documents like specifications or test plans;

• adapt to any development lifecycle—not only Agile;

• avoid the pesticide paradox, since exploratory sessions are never identical;

• significantly reduce the time spent writing and designing tests;

• execute more tests overall.

Perform Exploratory Tests

Although exploratory testing is freer and less structured than test-case-based testing, some best practices ensure quality and effectiveness.

In general, exploratory testing relies on test charters and heuristics. Let’s break these two notions down.

According to Elisabeth Hendrickson, a test charter can be written like this:

Explore a story, feature, or system with a set of resources, constraints, heuristics, or personas to discover information.

Examples of test charters:

1. Explore profile editing using script injections to uncover security vulnerabilities.

2. Explore profile editing with different user types to discover interactions between profile editing and user roles.

Test charters guide exploratory test sessions.

The organization of an exploratory test session follows these principles:

• conduct timed sessions limited by the charter;

• use one charter per session—one guideline to follow;

• execute and document at the same time;

• document every action;

• capture all test results;

• let each test’s results guide the next one;

• use tools such as heuristics and personas;

• create a report summarizing observations, comments, and defects.

After the session:

• review the bugs found and update specifications if needed.

Here are some examples of heuristics:

• Comparison: compare actual results with expected ones.

• Configuration: test different system configurations.

• Detection: look for signs of errors or abnormal behavior.

• Diversity: test a wide variety of scenarios.

• User experience: test from the user’s point of view.

• Reliability: ensure the software doesn’t crash or fail.

• Performance: check responsiveness and stability under load.

• Security: test for vulnerabilities and risks.

There are many other heuristics. With experience, you will select those most relevant to your project. They can also be combined for broader and more effective testing approaches.

Here are examples of web heuristics:

Determine the Limits of Exploratory Testing

Exploratory testing has many advantages, but also several limitations:

• It is highly tester-dependent: two testers using the same test charter will test differently and find different issues.

• Two exploratory campaigns are never identical, even when run by the same person.

• It is less rigorous and structured than functional testing.

• It is often informal and may not cover all features evenly.

• It cannot be automated.

• It is not sufficient on its own. It complements other testing methods.

Over to You!

For this activity, you’ll perform exploratory tests on two features of the Jardin Actuel website.

Instructions:

• Access the Jardin Actuel site.

• Focus on the following features:

  • contact form,

  • social media sharing buttons.

• Perform exploratory tests for both features. Note unexpected behaviors, bugs, or errors in the template (exploratory tests in .xlxs format): one table per feature.

• For each defect, document its description, reproduction steps, and test data used.

Summary

• Exploratory tests are not random; they are structured to deliver maximum value.

• They are run in dedicated sessions and guided by test charters.

• A test heuristic uses principles or rules to guide testing.

• Exploratory testing has limits and cannot stand alone.

Now that you’ve explored different ways to uncover defects, let’s move on to analyzing them.