10 Different Types of Manual Testing You Should Know

Manual testing is the process of testing software by hand — without automation tools — to identify bugs, validate functionality, and ensure the software meets business and user requirements. While automated testing has grown significantly, manual testing remains irreplaceable for UI/UX validation, exploratory testing, and scenarios where human judgment is the point.

There are ten core manual testing types. Knowing which to use, and when, determines how effective your QA coverage actually is.

All 10 Types at a Glance

1. Black Box Testing

Black box testing is a manual testing approach where the internal workings of the software are not known to or considered by the tester. The focus is entirely on inputs and outputs — validating functionality without examining the underlying code.

Black box testing is a broad category that contains both functional and non-functional subtypes.

Functional Testing

Functional testing validates that all specified business requirements and features work as expected. Testers provide different inputs and verify the actual outputs match the expected ones. Examples include:

• Unit Testing — testing individual functions or classes in isolation
• Integration Testing — testing units together as a group
• Smoke / Sanity Testing — quick validation of critical functionality before deeper testing
• System Testing — testing the entire system end-to-end

Non-Functional Testing

Non-functional testing verifies aspects like usability, performance, security, and compatibility — focusing on the quality of how the software operates rather than what it does. Examples include usability testing, performance testing, security testing, and compatibility testing.

2. White Box Testing

White box testing takes the opposite approach. The internal structure and code implementation are known and used to guide testing — the goal is to exercise the code itself, not just observe outputs.

Code Coverage

Checks how much of the source code is executed by tests. Metrics like statement coverage, branch coverage, and path coverage show how thoroughly tests exercise the codebase. The goal is maximum coverage to ensure all code paths are tested.

Path Testing

Executes all the different logical paths through the code. Complex code with conditional branches creates many possible execution paths — path testing verifies each one to uncover bugs that only occur on specific branches.

Loop Testing

Focuses specifically on validating loops — testing all paths through loop constructs with different values to check for issues like endless loops, off-by-one errors, and incorrect iteration counts.

3. Gray Box Testing

Gray box testing combines black box and white box approaches. The internal workings are only partially known — testers design test cases using available documentation like requirements specs and architecture docs, plus high-level knowledge of the system's internals.

The advantage: you get a peek inside the box to design better test cases than pure black box testing allows, without relying entirely on internal code knowledge the way white box testing does.

4. Exploratory Testing

Exploratory testing is an informal, knowledge-driven approach with no predefined test cases. Testers actively explore the software to find defects, guided by their experience, intuition, and domain knowledge.

Key characteristics: relies on tester skill and experience, fully unscripted, flexible scope, and bugs are documented as they are discovered. Exploratory sessions consistently surface defects that scripted tests miss — often the most interesting and highest-impact ones.

5. Usability Testing

Usability testing evaluates how easy and satisfying the software interface is for real users. Participants complete predefined tasks while testers observe where they struggle, make errors, or express confusion.

Key data collected: task success and failure rates, number of errors, time taken per task, and user satisfaction scores. These are insights only real users can provide — there is no substitute for watching a person interact with your product.

6. Ad-hoc Testing

Ad-hoc testing is unstructured and unplanned — testers randomly explore the software with no specific test plan or cases guiding them. Whatever functionality comes to mind gets tested. Bugs and crashes are logged as discovered.

The goal is to find defects in areas testers arbitrarily decide to check. Ad-hoc testing adds diversity to your testing approach by incorporating the unpredictability of human exploration, reaching corners formal test suites rarely touch.

7. Regression Testing

Regression testing re-tests existing, unchanged functionality after a change is made — a new feature, a bug fix, a configuration update. The goal is to confirm that changes didn't break something that was previously working.

Regression testing provides confidence that software enhancements don't introduce unintentional side effects. It is one of the most important continuous lines of defense against the introduction of new bugs.

8. Acceptance Testing

Acceptance testing is the final validation phase before release. It confirms the software meets both business and user expectations.

• User Acceptance Testing (UAT) — real users test the software to confirm it handles required tasks in real-world scenarios
• Business Acceptance Testing (BAT) — business stakeholders verify the system is complete and aligned with business requirements

Acceptance testing provides the critical final sign-off that the software is truly ready for deployment.

9. Compatibility Testing

Compatibility testing verifies the software works as expected across different environments — operating systems (Windows, Linux, macOS), browsers (Chrome, Firefox, Safari), devices (desktop, tablet, mobile), and screen resolutions. It ensures your software works seamlessly across the heterogeneous platforms your users actually have.

10. Performance Testing

Performance testing checks the software's behaviour under load — response times, resource usage under peak concurrent users, reliability during prolonged usage, and stability under sudden traffic spikes. The focus is validating acceptable performance under anticipated real-world conditions and identifying bottlenecks before they reach production.

Conclusion

Manual testing continues to hold an indispensable place in the QA process. The human touch of manual testing reveals issues that automated testing cannot — particularly in UI/UX, exploratory edge cases, and acceptance validation.

Using a combination of black box, white box, gray box, exploratory, usability, regression, acceptance, compatibility, and performance testing gives you comprehensive validation of your software's functionality, usability, and release-readiness. The right mix depends on your project — choosing correctly is itself a QA skill.