Manual Testing: How We Make Sure Software Works Correctly

Collapse
X
 
  • Time
  • Show
Clear All
new posts
  • MyrinNew
    Senior Member
    • Feb 2024
    • 5168

    #1

    Manual Testing: How We Make Sure Software Works Correctly

    Have you ever played a video game that suddenly stopped working? Or used an app that showed the wrong answer? That happens when software is not tested properly. That is where Software Testing comes in. Testing is simply the act of checking whether a software application is working the way it is supposed to work.


    In this blog, I will talk about four very important topics in software testing:

    1. Common Manual Testing Techniques
    2. Boundary Value Analysis
    3. Decision Table Testing
    4. The Future of Manual Testing in the Age of AI
      Let us begin!





    1. Common Manual Testing Techniques

    Think of manual testing like a human inspector at a factory. Instead of a machine checking the product, a real person uses the software and checks if it works correctly. The person does this step by step, without using any automated tools.


    Here are the most common ways manual testing is done:


    Exploratory Testing

    In this technique, the tester does not follow a fixed script. Instead, they explore the software freely — just like how you would explore a new video game without reading the instruction manual. The tester uses their experience and curiosity to find bugs.


    For example, a tester might try typing very long names in a form or clicking buttons very fast to see if the software breaks.


    Black Box Testing

    In black box testing, the tester does not know how the software is built inside. They only look at what goes in (input) and what comes out (output). It is like using a TV remote — you press a button and check if the right channel appears. You do not care how the electronics inside work.


    This is very useful because real users also do not know the internal code. So this testing checks the software from the user's point of view.


    White Box Testing

    This is the opposite of black box testing. Here, the tester knows the internal code of the software. They check if each part of the code is working correctly. This is like a mechanic opening a car's engine and checking each part carefully.


    Smoke Testing

    Before doing detailed testing, testers first do a quick check to see if the software starts and basic things work. This is called smoke testing. It is like switching on a new TV — first you just check if it turns on and shows a picture. If that does not work, there is no point checking other features.


    Regression Testing

    Every time developers make a change or fix a bug, testers check whether the fix accidentally broke something else. This is called regression testing. Imagine if someone fixed a leaking pipe but accidentally broke a window — you would want to check everything after repairs.


    User Acceptance Testing (UAT)

    Before software is released to real users, it is given to a small group of actual users to test. They check if the software does what they expected. If they are happy, the software is approved for release.





    2. Boundary Value Analysis

    Now let us talk about a very clever testing technique called Boundary Value Analysis, or BVA.


    Imagine your school says students must be between 5 and 18 years old to join. The "boundaries" are 5 and 18. Boundary Value Analysis says: most bugs hide near the edges, not in the middle.


    So if a form accepts ages from 5 to 18, a good tester would check:
    • Just below the minimum: age 4 (should be rejected)
    • Exactly at the minimum: age 5 (should be accepted)
    • Just above the minimum: age 6 (should be accepted)
    • Just below the maximum: age 17 (should be accepted)
    • Exactly at the maximum: age 18 (should be accepted)
    • Just above the maximum: age 19 (should be rejected)
      Why do bugs hide at boundaries? Because when programmers write code, they sometimes make small mistakes like writing > instead of >=. These small mistakes cause the software to behave incorrectly at the edges.


    Real-life Example at NSDL

    At my workplace, we test demat account opening forms. If a PAN number must be exactly 10 characters, we test with 9 characters, 10 characters, and 11 characters. This way, we catch bugs that only appear at the exact edges of the allowed range.


    Why BVA is powerful:
    • It reduces the number of test cases needed
    • It finds bugs that normal testing might miss


    - It is simple, logical, and easy to explain

    3. Decision Table Testing

    Now let us talk about Decision Table Testing. This technique is used when software behaves differently based on different combinations of conditions.


    Let me give you a fun example. Imagine a pizza app with these rules:


    Yes Yes 30% off
    Yes No 10% off
    No Yes 15% off
    No No No discount


    This table shows every possible combination of conditions and what the system should do. This is a Decision Table.


    Why Do We Need Decision Tables?

    Sometimes software has many rules that interact with each other. It is very easy to miss a combination. A decision table makes sure we test every single combination of conditions.


    How to Create a Decision Table

    Step 1 — List all the conditions (for example: is the user logged in? Is the payment successful? Is the item in stock?)


    Step 2 — List all the actions or results (for example: show order confirmation, show error message)


    Step 3 — Fill in every possible combination of Yes/No for each condition


    Step 4 — Write test cases for each column of the table


    Real-life Example

    At NSDL, when we test KYC validation for demat accounts, we deal with multiple conditions:
    • Is the PAN number valid?
    • Is the KRA database responding?
    • Is the account type individual or corporate?
      Each combination needs to be tested. Decision table testing ensures we do not miss any scenario, which is very important in financial software where errors can affect real money and real accounts.





    4. The Future of Manual Testing in the Age of AI

    This is the most exciting topic! The world is changing very fast. AI (Artificial Intelligence) tools are becoming part of every industry, including software testing. So what will happen to manual testers like us?


    What AI Is Already Doing in Testing

    AI tools can now:
    • Write test cases automatically by reading the requirements
    • Find bugs faster by learning from past bug patterns
    • Run thousands of tests in a few minutes (automated testing)
    • Predict which parts of the software are likely to have bugs
      Tools like Selenium, Appium, and AI-powered platforms like Testim, Mabl, and Functionize are already being used by companies to speed up testing.


    Will AI Replace Manual Testers?

    This is the big question everyone is asking. The honest answer is: AI will not replace manual testers — it will change what manual testers do.


    Here is why:


    AI is very good at repetitive tasks. Running the same test 1000 times? AI wins. But AI cannot think creatively. It cannot understand human emotions, user experience, or business logic the way a human can.


    Manual testers are still needed for:
    • Exploratory testing, where creativity and curiosity matter
    • Understanding business requirements and user expectations
    • Testing usability — does the app feel easy and natural to use?
    • Ethical testing — is the software fair to all users?
    • Reviewing AI-generated test results and deciding what they mean
      ### The New Role of Manual Testers


    The future manual tester will be someone who:

    1. Understands AI tools and knows how to work with them
    2. Writes smart test strategies that AI can execute
    3. Focuses on exploratory and risk-based testing — areas where human judgment is needed
    4. Knows API testing and database validation — skills that remain relevant
    5. Learns automation basics — at least enough to collaborate with automation engineers
      ### My Personal Journey


    As a QA engineer at NSDL, I have already started this journey. I independently learned Postman for API testing and built Mock Servers to simulate external systems. I have also started Core Java and Selenium training to move towards automation.


    The message is clear: upskill, adapt, and stay curious. Manual testers who keep learning will not only survive but thrive in the AI era.





    Conclusion

    Software testing is not just about finding bugs. It is about making sure that when you press a button in an app, the right thing happens. Techniques like Boundary Value Analysis and Decision Table Testing help testers be smart and organized. And even as AI becomes more powerful, human testers will always be needed to bring judgment, creativity, and business understanding to the table.


    If you are a beginner in testing — start today. Learn the basics, practice on real projects, and never stop learning. The field is growing, and there is a place for everyone who is willing to work hard.


    Happy Testing!





    Published by Gayatri Suryavanshi | QA Engineer | NSDL Mumbai

    Connect with me on LinkedIn | GitHub




    More...
Working...