
Adhoc testing is an informal software testing method used to find defects without following predefined test cases or detailed instructions. Instead of working through a prepared checklist, testers interact with an application, try different actions, and observe how the software responds. This approach allows testers to investigate unexpected behavior that might escape planned testing. A tester might enter unusual information into a form, interrupt a transaction, or move between screens in an unexpected order. These actions can reveal problems that are difficult to anticipate when writing formal test cases.
The International Software Testing Qualifications Board (ISTQB) describes ad hoc testing as an informal activity performed without prior test analysis and design. Although the method requires little formal preparation, useful results depend on careful observation, product knowledge, and the ability to recognize unusual behavior.
Table of Contents
What Makes This Testing Method Different?
Most structured software testing begins with an expected result. A tester receives instructions describing an action, the conditions under which it should be performed, and the correct outcome. Informal testing works differently. The tester chooses actions while using the application, often following unexpected results into areas that were not originally considered. For example, a planned test might confirm that a registration form accepts a valid email address. An unscripted check could involve entering spaces, submitting the form repeatedly, leaving fields blank, or refreshing the page during submission. These actions are not necessarily part of the original requirements, but they can expose weaknesses in input validation, error handling, and application behavior.
The method has several defining characteristics:
- No predetermined test sequence: Testers decide which actions to perform during execution.
- Flexible investigation: Unexpected behavior can lead immediately to additional checks.
- Experience-based decisions: Previous defects and knowledge of the application help testers identify suspicious areas.
- Minimal preparation: Formal test scripts are not required before testing begins.
- Uncertain coverage: Without recorded test conditions, it can be difficult to establish what has been checked.
The absence of a script does not mean that every action should be completely random. An experienced tester can make informed choices while keeping the activity informal.
How Informal Software Testing Works
There is no mandatory sequence for conducting an informal test. However, a practical approach can help testers use their time effectively without turning the activity into a fully scripted process.
Become Familiar With the Application
Before investigating unusual behavior, the tester needs a basic understanding of what the software is supposed to do. This may involve reviewing the main features, observing ordinary user interactions, or reading available product requirements. Consider an online banking application. A tester should understand how account balances, transfers, and transaction records normally work before attempting unexpected operations. Without this context, distinguishing a software defect from intended behavior becomes difficult.
Interact Beyond Normal Usage
After learning the application’s basic functions, the tester can try actions that differ from typical usage.
Examples include:
- Submitting forms with missing or unusually long values.
- Clicking buttons several times in quick succession.
- Refreshing a page while information is being saved.
- Moving backward through a multistep process.
- Opening the same feature in multiple browser tabs.
- Interrupting an action before it finishes.
- Switching between screens while a request is processing.
The goal is to observe whether the application handles these situations correctly. Some unexpected results are harmless. Others may reveal missing validation, incorrect calculations, lost data, or confusing error messages.
Investigate Unexpected Results
When something unusual happens, the tester should try to understand the circumstances. Suppose an application displays the wrong total after a discount is applied. The tester might repeat the process with different quantities, remove the discount, or change the order in which items are added. These checks help establish whether the problem occurs consistently and under which conditions. The investigation may also reveal that the issue is limited to a particular browser, account state, or combination of inputs.
Record Useful Findings
Formal test cases may not exist, but discovered defects still need clear documentation. A useful defect report should identify the affected feature, describe the observed behavior, and explain the circumstances that produced it. Without this information, developers may struggle to reproduce the problem, even when the tester is certain that something went wrong.
A Practical Example: Testing an Online Store
An online shopping website offers a useful example of how unscripted checks can expose unexpected behavior. Imagine that the website has already passed basic tests for searching products, adding items to a cart, and completing purchases. A tester decides to investigate the shopping cart without following a prepared script.
First, the tester adds three products, changes their quantities, and removes one item. Next, they open the cart in another browser tab and modify the contents there. They then return to the original tab and attempt to continue checkout.
Several questions may arise: Does the application display the correct quantities in both tabs? Does the total update correctly? Could an outdated cart state replace more recent changes? The tester might continue by applying a discount code, changing the delivery address, or refreshing the checkout page. If the website produces inconsistent totals or loses items, the behavior deserves further investigation.
This is an illustrative scenario, not a report of defects found in a particular shopping platform. It demonstrates why testing familiar features through unfamiliar sequences can be useful. Individually, each action may work correctly, while combinations of actions expose problems.
Informal Testing Compared With Exploratory Testing
Ad hoc and exploratory testing are sometimes treated as interchangeable terms. Both allow testers to work without following detailed predefined scripts, but they are not identical. Exploratory testing involves learning about the software while designing, executing, and evaluating tests. The tester uses findings from earlier actions to decide what to investigate next. According to ISTQB, exploratory testing can also use structured sessions with defined objectives, known as test charters. The main differences are easier to see side by side.
| Aspect | Ad hoc approach | Exploratory approach |
|---|---|---|
| Planning | Little or no formal preparation | May use goals or test charters |
| Execution | Informal and improvised | Guided by learning and observations |
| Documentation | Often limited | May include session notes and coverage records |
| Main emphasis | Finding defects through unscripted actions | Learning about the system while investigating risks |
| Test coverage | Often difficult to measure | Can be tracked through session records |
The boundary is not always strict in everyday software teams. A tester may begin with informal checks and gradually develop a more focused exploratory investigation. However, a time-boxed session with clearly defined objectives and recorded coverage is more characteristic of structured exploratory testing than a purely improvised test.
Different Ways Testers Investigate Software
Informal testing does not have a universally required set of subtypes. Still, several common working styles are worth understanding.
Independent Investigation
A single tester explores the software based on their knowledge of the application. This is useful when investigating a recently changed feature or following up on behavior that appears suspicious. The tester can change direction immediately without coordinating every action with another person.
Pair Investigation
Two people examine the application together. One may operate the software while the other observes, questions assumptions, or suggests additional scenarios. For example, a tester and developer might investigate a complex form after an unusual validation error appears. Working together can provide different perspectives, although it also requires both participants’ time.
Defect-Focused Investigation
A tester may focus on areas associated with previous failures, such as date calculations, session handling, or payment processing. This overlaps with error guessing, an experience-based technique recognized by ISTQB. Error guessing uses knowledge of common mistakes and previous defects to anticipate where problems may occur. Unlike purely informal investigation, it is recognized as a test design technique.
When Is This Approach Most Useful?
Informal checks can support software development at several stages.
After a small code change: A tester can quickly examine the modified feature and nearby functionality before more extensive testing begins.
During early development: When requirements or interfaces are changing, improvised checks can reveal obvious problems without requiring detailed test documentation for every interaction.
After formal test execution: Once planned tests have passed, testers may investigate unusual workflows that were not covered by existing cases.
When reproducing customer complaints: A report describing inconsistent behavior may require experimentation before the exact conditions become clear.
During usability investigations: Unscripted interaction may reveal confusing navigation, unclear messages, or workflows that behave unexpectedly.
However, informal checks should not be the only basis for deciding whether complex or high-risk software is ready for release.
Important Limitations to Consider
The greatest weakness of this method is the uncertainty surrounding test coverage. A tester might investigate one feature thoroughly while overlooking another completely. Without documented test conditions, there is no reliable way to demonstrate that all important requirements have been checked. Another difficulty is reproducibility. If a defect appears during an improvised sequence and the tester does not record the actions, reproducing the failure may be difficult. Results also depend heavily on the individual’s experience. Someone familiar with common software failures may recognize risky interactions that a less experienced tester would overlook. However, experience alone cannot guarantee adequate coverage.
There are additional limitations:
- Repeating exactly the same tests can be difficult.
- Results may vary between testers.
- Testing progress is harder to measure.
- Important requirements may be missed.
- Unrecorded findings cannot easily become regression tests.
Good adhoc testing can reveal unexpected defects, but it cannot establish that an application satisfies every requirement. For regulated systems, financial calculations, security-sensitive processes, or other high-risk functions, documented verification and appropriate specialist testing remain necessary.
Turning Unexpected Findings Into Reliable Test Cases
An improvised investigation becomes more valuable when the team preserves important discoveries. Suppose a tester finds that a form accepts an invalid date and then displays an incorrect result. Instead of simply reporting that the form is broken, the tester should record the information needed to reproduce the issue.
A practical defect report could include:
- Affected feature: The form or page where the problem occurred.
- Environment: Browser, device, application version, and relevant settings.
- Steps to reproduce: The actions performed before the failure.
- Expected behavior: What should have happened according to the requirements.
- Actual behavior: What the application displayed or performed.
- Supporting evidence: Screenshots, recordings, logs, or relevant input values.
Microsoft’s Azure Test Plans documentation describes similar practices for recording exploratory testing findings, including screenshots, action logs, and defect reports. Once developers fix a reproducible problem, the team can create a formal regression test to check that the same behavior does not return in later versions. When suitable, that regression check may be automated. This creates a useful connection between informal investigation and structured quality assurance. Unexpected behavior becomes a documented scenario that can be checked consistently.
Questions Readers Often Ask
Can beginners perform informal software testing?
Yes. Beginners can investigate applications without formal scripts, especially when checking familiar workflows. However, they should first understand the application’s expected behavior. Learning basic testing concepts such as input validation, test conditions, expected results, and defect reporting will make their observations more useful.
Is this method considered black-box testing?
It often involves black-box testing because the tester interacts with the software without examining its internal code. However, the terms describe different things. Black-box testing concerns the information used to design tests, while ad hoc describes the informal nature of the testing activity. An experienced developer could also perform unscripted checks while using knowledge of the internal implementation.
Does informal testing require special tools?
No. Many checks can be performed directly through a website or application. Nevertheless, browser developer tools, screen-recording software, defect trackers, and log viewers may help capture evidence and investigate unusual behavior. Tools support the investigation; they do not determine whether the testing is informal.
Can unscripted testing be automated?
The improvised decision-making process is usually performed manually because the tester selects actions based on observations. However, a scenario discovered during an informal session can later be converted into an automated regression test. This allows the team to preserve a useful discovery without repeatedly performing the same manual actions.
How much time should a team spend on it?
There is no universal duration. The appropriate amount depends on the software’s complexity, the risks involved, recent changes, and the team’s broader testing strategy. A short investigation may be reasonable for a small interface adjustment, while a complex workflow may require longer examination. Time limits can help control effort, but they should not be confused with evidence of complete coverage.
Keeping Informal Testing in Perspective
The value of unscripted testing comes from examining software beyond the situations anticipated during formal test design. It can expose unusual interactions, unclear error handling, and unexpected combinations of actions. These findings are especially useful when they are recorded and converted into repeatable checks. The most reliable testing strategies do not depend on improvisation alone. They combine documented requirements, planned verification, and thoughtful investigation of situations that formal scripts may have missed.
