Exploratory Testing in Agile Developments.

Written by Nasima Alam, Test Analyst,   Nov 30, 2021

As a Test Analyst at Infomentum, I generally follow a formal structured test process, one that is promoted by certification bodies such as ISTQB. It ensures that we adhere to the best practices and verify that the software under test meets our requirements. But is it always enough? In my experience, no. On occasion, a more experimental method of testing is a more suitable approach for that given project. Great news, it also fits nicely with an agile development cycle!

What is Explanatory testing?

Exploratory Testing (ET) is an approach to software testing that is essentially about the discovery & investigation of an application. It relies on the guidance of the individual tester to uncover defects that are not easily covered in the scope of other tests. In simpler terms, ET brings the learning (about the program) and the testing processes together.

ET ensures that:

  • A tester has a more comprehensive understanding of how software should work.
  • The tester is well equipped to create more effective tests that quickly identify major defects in the system.
  • Defects that may not have been otherwise found via structured testing are identified.


So how does Exploratory testing differ from Structured testing?

Structured testing is designed to verify that the tested software meets a set of specified requirements. Testing is directed and constrained by the Design Specification and Test Plan. Both of which may have been created long before a line of code was written.

Exploratory testing uses the method of discovery, investigation and learning - giving me as a tester more freedom and responsibility.

In the absence of formal test cases or “Scenarios”, it's all up to the tester. Depending on the project I am working on, I may note down ideas prior to the test, or test on the fly. Both approaches are work well, as the focus of exploratory testing is on it being a “thinking” activity vs the pre-prescribed.

Structured vs Exploratory Testing

The different approaches in Structured testing and Exploratory testing

I have found Exploratory testing to be an excellent way to learn both the strengths and weaknesses of the software. With its focus on quickly finding defects and issues within the application, it gives developers the opportunity to tackle the major bugs head-on. By identifying the defects early on, we reduce the repeating mistakes and move quicker and smoother through the development cycle.

Skills required for Exploratory testing

Testing what approach to choose

Key things to consider before trying the exploratory testing

Exploratory testing is a creative context-driven activity that is focused on finding defects and issues within the application and then publishing all detected defects.

While it does not necessarily require any formal documentation, considering the following is key to ensuring you maximise the potential of your exploratory test:

  • Test coverage – Has the quality of the software improved with existing documented test cases?
  • Risks - Identify priority risks to cover whilst exploratory testing.
  • Test Execution Log – Recordings on the test execution.
  • Issues / Queries – Take notes on any questions or issues which may arise whilst test.

While informal exploratory testing should be performed by everyone involved in the deployment of the application (including Business Analysts, Developers, Testers and End Users), formal Exploratory testing, which measures the production readiness of the application, should be performed by skilled context-driven testers.

ET and Agile

Exploratory Testing is an important activity when working in an agile environment. It shares the same fundamental value system of the Agile manifesto – that is, Continuous Integration.

When working on agile development, it is essential to continually facilitate changes according to project's needs. ET compliments this process swiftly; I can simultaneously source and provide feedback and further refine the testing process by building a solid approach towards development. This simultaneous process of continuous development, deployment and improvement helps me to keep up with the rapid development pace of agile software projects. It allows my teams to facilitate changes according to the project's needs while keeping within the software's life cycle.

Tools of ET

When performing Exploratory testing, I usually use a Text Editor to trace out my thoughts whilst testing, however, there are tools that can assist Exploratory Testing, enabling a tester to create notes and mind maps. This can be useful for documentation and reporting. Two of the most common tools are XMind and MindMup.

XMind is a mind mapping and brainstorming software. Users can insert notes, markers, stickers, hyperlinks, labels into the topics which can be in the form of PNG & PDF with a watermark.

Xmind mind map exploratory testingExample of XMind template that can help with test case execution and reporting.

One of many XMind templates that can help with test case execution and test reporting.

MindMup is another mind mapping software tool that enables a user to create mind maps, presentations and documents. It can be used to brainstorm ideas and share them online and on social networks.

Maps created in MindMup allow you to export your work as a PNG image as well as in several other formats as well and share online via MindMup.


Mindup map example exploratory testingMaps created in MindMup can be exported as images or shared online.

Benefits of Exploratory testing

Even when following a formal structured test process, there will always be advantages in using ET. I have found that ET compliments manual testing by identifying the key areas of the application that will be most used and then checking that these are fully functioning, for example when testing websites; Do the images load? Are the media videos playing? Is the mega menu working? Do forms submit etc. Often, I have used ET as a ‘Smoke test’ before executing formal test cases.

The main advantage here is that less preparation is required, and important bugs are found fast, leading to a quick defect resolution turnaround from Developers. I have found this particularly helpful on projects with very tight deadlines.

Using this approach enables me to use deductive reasoning based on the results of previous tests to guide my future testing on the fly. This eliminates the need to complete a current series of scripted tests before focusing on a more target-rich environment, accelerating bug detection.

As mentioned before, ET can be carried out in conjunction with a formal test process, however, ET is probably best utilised where there are last-minute changes required to an application or on projects where time and requirements are limited, thus making it the ideal test process to use.

Are you using the ET approach when testing? If not, we highly recommend you give it a try and incorporate it into your testing strategy!

Topics: Tech testing

We’d love to hear your opinion on this post