Manual Testing Guide for Product Testing

Manual Testing Guide: Key Techniques, BVA, Decision Tables & What’s Next with AI
By
Srinidhi MS – July 12,2025
Introduction
Even though automation and AI are growing fast, manual testing is still an important part of software development. Manual testers think and test like real users, helping find problems that machines might miss—especially usability and edge-case bugs.
In this blog, we’ll go over:

1. Common manual testing techniques
2. What is Boundary Value Analysis (BVA)?
3. What is Decision Table Testing?
4. The future of manual testing with AI tools Let’s understand the topics:
5. Common Manual Testing Techniques Manual testing means testing software without using automated tools or scripts. Instead, testers go through the applications/product step-by-step like an actual user would. Here are some popular manual testing methods: 1.1 Exploratory Testing In exploratory testing, you don’t follow a fixed test script. Instead, you explore the application/product freely based on your own understanding, checking if everything works and looks right. You learn the app as you test it. Why use it? • Helps find unexpected issues • Great when there’s little time or documentation • Encourages thinking outside the box

This is one of the most useful techniques in our project. Exploratory testing means navigating the swapping station software like an actual EV user would without following a test script. We look for unexpected behavior and issues, especially around:
• User authentication (e.g., RFID keyfob swipes)
• Battery availability status on the dock
• Unexpected station shutdowns
• Payment workflows

Exploratory testing helps catch issues that strict test cases may miss especially when new builds are deployed or after a hardware firmware update.

1.2 Ad-Hoc Testing
Ad-hoc testing is similar to exploratory testing, but even more unplanned. You test randomly without preparation, mainly using your experience to guess where things might break.
Good for:
• Quick last-minute testing
• Catching obvious bugs
• New builds with limited changes
Note: It’s not always repeatable or easy to document.
1.3 Use Case / Scenario Testing
Here, you test based on how real users would interact with the application.
For example, logging in, adding items to a cart, or checking out. You’re testing workflows instead of just individual features.
Why it’s useful:
• Focuses on real user behavior
• Finds problems that only appear when using multiple features together

1.4 Manual Regression Testing
This is when you re-test the application manually after changes or bug fixes. The goal is to make sure nothing else broke. Even if some tests are automated, many teams still do some manual regression especially for visual checks or new features.
1.5 Usability Testing
Here, you test how easy and user-friendly this application is. You look at things like button placement, messages, flow, and how users feel while using the app.
Why it's important:
• Helps improve user experience
• Catches confusing UI and poor design

1.6 Checklist Testing
This means having a checklist of key areas or features to test. It’s less detailed than full test cases but ensures nothing important is missed.
Great for:
• Quick coverage
• Making sure critical tests are not skipped

1. Boundary Value Analysis (BVA) Boundary Value Analysis (BVA) is a testing method where you test the edge or “boundary” values of input fields. Most bugs happen at these limits, like minimum/maximum numbers. Example: If a form only accepts values between 1 and 100: Test Case Input Expected Result Lower limit 1 Accept Just below 0 Reject Just above 2 Accept Upper limit 100 Accept Just below 99 Accept Just above 101 Reject

One more Example
Why BVA works:
• Most errors happen at boundaries (e.g., "off by one" bugs)
• Saves time—only test key values instead of every number
• Great for input fields, ranges, and validations
Tips for BVA:
• Test minimum, maximum, and just outside values
• Combine with normal (middle) values
• Think of edge cases, like zero, blanks, and large numbers

1. Decision Table Testing This method is used when there are multiple rules or conditions that affect the outcome. You put these into a table to cover every possible combination of inputs and outputs. Example: Let’s say: • If order total is over $50 and the user is a member → Free shipping • Otherwise → Standard shipping

Your table would look like this:
Order ≥ $50 Is Member Shipping Fee
Yes Yes Free
Yes No Not Free
No Yes Not Free
No No Not Free
Now, you test all these combinations.
Why use it?
• Makes complex rules easier to test
• Ensures no combinations are missed
• Great for forms, pricing, permissions, etc.
How to use it:
• List out all input conditions
• Define what result each condition leads to
• Write test cases for each row in the table

1. The Future of Manual Testing in the Age of AI AI is changing the way we test software—but manual testing is not going away any time soon. Here’s what’s changing and what’s staying: How AI is Helping Testers • AI tools can generate test cases, write test scripts, and run them • Tools like Testim, Functionize, and Mabl use AI to auto-heal broken tests when UI changes • Some tools understand natural language, so testers can write tests in plain English What AI Can’t Do Well (Yet) • Human judgment: AI doesn’t understand what’s confusing or frustrating for users • Exploratory testing: AI can’t think like a curious tester following a gut feeling • Real user experience: AI won’t notice awkward designs or unclear labels • Ethics and accessibility: AI often misses issues that affect real people in real situations What This Means for Testers Manual testers aren’t being replaced—they’re evolving. The future tester will: • Use AI tools to save time and effort • Still explore, observe, and think critically • Focus more on test strategy and less on repetitive tasks • Help build user-friendly and inclusive software How You Can Stay Ready • Learn about new AI testing tools • Understand your app’s business rules and logic • Improve your communication and problem-solving skills • Stay curious and open to learning new things Final Thoughts Manual testing is still powerful—especially when it’s done right. Techniques like exploratory testing, boundary value analysis, and decision tables help testers find bugs faster and more efficiently. While AI is here to help us do more, it can’t replace the human eye and brain just yet. As testers, we need to combine the best of both worlds—using AI tools and applying human thinking to deliver high-quality, user-friendly software.