Manual Testing: A Beginner’s Guide

Pragya Yadav

The global software testing market exceeded $40 billion in 2020 and is expected to grow between 7% to 12% CAGR between 2021 and 2025. It is an excellent career choice with ample opportunities for growth and learning.

If you want to pursue a manual testing career, this article presents the foundation concepts to help you kick-start your testing journey with vigor.

What is Manual Testing?

ISTQB defines testing as “The process within the software development lifecycle that evaluates the quality of a component or system and related work products.”

When this QA process is executed manually to identify defects, errors, or issues within a software application, it is called manual testing. It involves human testers interacting with the software as end-users would, without using automation tools or scripts.

In manual software testing, testers follow predefined test cases, scenarios, or user stories to simulate various user interactions and workflows within the software. They perform tasks such as inputting data, navigating through different screens, and verifying that the software behaves as expected.

Advantages of Manual Testing

Though manual testing tends to get a bad reputation due to some of its shortcomings, it is still a beautiful way to vet software.

• Human Perspective: Manual testing lets you think and act like a real user. You can catch issues with design, usability, or workflows that automated tools might miss because they don’t “think” like humans.
• Flexible and Adaptable: You can quickly adjust your tests if something changes. For example, if a developer makes a last-minute update, you can test it right away without needing to update any scripts.
• Great for Exploratory Testing: When you’re trying to discover unknown bugs, manual testing is perfect. You can poke around and explore areas that might not be covered by pre-written test cases.
• No Special Setup Required: Manual testing doesn’t need advanced tools or programming skills. All you need is the software to test, and you’re good to go.
• Tests Unique Scenarios: Sometimes, users do weird things like entering emojis in a form or clicking buttons in unexpected ways. Manual testing helps uncover these edge cases that automation might overlook.
• No Maintenance Hassles: Automated tests need constant updates when the software changes. With manual testing, you simply adjust your approach on the fly without worrying about maintaining test scripts.

Testing Concepts You Should Know

Here are a few popular manual testing concepts, i.e., testing terminologies that are used frequently in the testing process, and you should have an idea of what they are:

Test Scenario

It is a specific situation or condition that a tester creates to test a particular aspect of a software application. It describes the intended behavior of the application under certain circumstances. Test scenarios provide a broader context than individual test cases, encompassing multiple test cases that collectively validate a specific functionality, requirement, or use case.

Example: Consider an e-commerce application where the user must register first. The broader test scenario is user registration.

• Test Scenario: User Registration Process
• Objective: To verify that the user registration process of a website functions correctly and captures accurate user information.

Test Case

It is a detailed description of a specific test that needs to be executed to verify a particular aspect or functionality of a software application. It outlines the steps to be followed, the inputs provided, the expected outcomes, and any specific conditions or prerequisites required for the test.

Example: There can be multiple test cases for the before-mentioned test scenario. Here, we are considering one test case where the email id already exists in the database, and the user should receive an appropriate error message during registration.

• Test Case: Existing Email
• Preconditions: The user is on the registration page, and the email ID is already registered.
• Steps:
  • Step 1: Enter valid user details, including an already registered email.
  • Step 2: Click the “Register” button.
• Expected Result: An error message indicates that the email is already in use and the user is not registered.

Test Environment

It is a controlled setup that mimics the real-world conditions under which software testing is conducted. It includes hardware, software, network configurations, and other resources necessary for testing the software application. Creating a well-defined test environment ensures testing results are accurate, repeatable, and consistent. This environment allows the testing team to identify issues and verify the software’s behavior under various conditions.

Example: The hardware and software components are configured to match the anticipated production environment.

• Hardware: A dedicated server with specifications similar to the production environment, including CPU, memory, and storage.
• Software: Web Server: Apache or Nginx, Application Server: Tomcat or Node.js, Database Server: MySQL or PostgreSQL, Operating System: Ubuntu Linux, etc.

Test Data

Test data refers to the input values, configurations, and datasets used to execute test cases and during software testing. It helps verify that the software functions correctly and produces accurate results under different conditions. Test data can include various inputs, covering both valid and invalid scenarios.

Example:

• Test Case: Verify age validation for user registration (age must be between 18 and 65).
• Test Data:
  Age: 17 (below the valid range)
  Age: 18 (minimum valid age)
  Age: 30 (within the valid range)
  Age: 65 (maximum valid age)
  Age: 66 (above the valid range)

Test Execution

It is to execute the predefined test cases on the software application to assess its functionality, performance, and other aspects. The primary goal of test execution is to validate whether the software behaves as expected, identify defects, and ensure that it meets the defined requirements.

Test Result

It is the outcome or status of the execution of a specific test case, test scenario, or a series of tests performed on a software application. It provides information about whether the software behaved as expected, whether any defects were identified, and whether the test passed or failed based on predefined criteria.

Example: Test Case: User Login

• Status: Pass
• Expected Outcome: The user should be able to log in using valid credentials.
• Actual Outcome: The user successfully logged in and accessed the dashboard.
• Defects: None identified.
• Comments: The test was executed on Chrome browser, version 92, using a test user account.
• Attachments: Screenshot of the dashboard after successful login.
• Test Environment: Windows 10, Chrome 92.

Defect or Bug

A defect is a flaw, error, or unintended behavior in a software application that causes it to deviate from its intended functionality. Defects can arise at various stages of the software development lifecycle- design, coding, testing, and deployment. They can manifest as incorrect behavior, crashes, unexpected results, or other issues that affect the software’s performance, reliability, or user experience.

Example: A user cannot pay on the checkout page of an e-commerce website due to a broken “Continue to Payment” button.

Defect Lifecycle

It refers to a defect’s various stages- discovery or resolution in software development and testing. This lifecycle outlines the steps in identifying, documenting, prioritizing, fixing, verifying(retesting), and closing defects to ensure the software meets quality standards.

Test Plan

A test plan is a comprehensive document that outlines the software testing effort’s approach, scope, objectives, resources, schedule, and deliverables. It serves as a roadmap or guide for the testing process, detailing how testing activities will be conducted to ensure that the software meets quality standards and fulfills its requirements.

Here is a detailed test plan template.

Test Strategy

A test strategy is a high-level document that provides a strategic framework to guide the planning, design, execution, and management of testing activities throughout the project’s lifecycle.

While a test plan focuses on elaborating the test objectives, a schedule, and ways to achieve them, the test strategy focuses more on how to go about the actual testing activities. Get a clear picture of the test plan vs. test strategy.

Severity and Priority

Severity refers to the extent of a particular defect’s impact on a software application. It measures the effect of the defect on the software’s performance and its consequences for overall functionality.

Priority, conversely, is a decisive factor determining the order in which defects should be addressed. A defect with a higher priority should be resolved before those with lower priorities.

Read an article on severity vs. priority to understand better.

Verification and Validation

Verification is – are we building the product right? It involves checking that the software is constructed correctly according to its intended design and adheres to the established standards and guidelines. Verification activities ensure the software is consistent with its documentation and accurately implements the desired functionality.

Validation is – are we building the right product? It involves assessing that the software fulfills its intended purpose and provides value to its users. Validation activities ensure that the software is fit for its intended use in the real-world environment.

Software Testing Life Cycle(STLC)

STLC stands for Software Testing Life Cycle. It is a systematic and structured approach to planning, designing, executing, and managing software testing activities throughout the software development process. STLC outlines the various phases, tasks, and activities that testing teams should follow. It ensures the software application meets quality standards, functions correctly, and delivers a reliable user experience. Read in detail about STLC.

Test Case Example

Consider a real-world example in the context of an online shopping website.

Scenario: Testing the Add to Cart functionality.

Test Case: Verify that a user can add items to the shopping cart successfully.

Expected Result: The confirmation message appears after clicking “Add to Cart,” the item is listed in the cart, and the total value is updated correctly.

Actual Result: The confirmation message appeared, and the total value was updated correctly.

Defect: Document a defect if discrepancies or issues are found (e.g., the confirmation message doesn’t appear, the item is not added to the cart, or the total value is incorrect).

Notes: During the testing process, you might use different browsers (Chrome, Firefox, Safari) and devices (desktop, mobile) to ensure compatibility. To uncover potential issues, you may explore negative scenarios (attempting to add an out-of-stock item).

Testing Levels

The testing pyramid below depicts the four broad levels of testing.

• Unit Tests: The smallest software unit (method, few lines of code) is tested individually.
• Integration Tests: Two or more code units are integrated, and their interaction and data exchange are tested.
• System Tests: The whole system is combined and tested as a single unit.
• Acceptance Tests: The final system is tested from the end user’s perspective.

Types of Testing

Software testing encompasses various testing types to assess different aspects of a software application.

• Functional testing focuses on verifying that the software functions as intended.
• Non-functional testing evaluates factors like performance, security, and usability.
• Unit testing involves testing individual components.
• Integration testing checks the interaction between modules.
• Regression testing ensures that new changes do not affect existing functionality.
• User acceptance testing involves users validating that the software meets their needs.
• Performance testing assesses responsiveness and scalability.
• Security testing identifies vulnerabilities, threats, and security loopholes.
• Compatibility testing ensures the software works across various platforms and configurations.

Here is more information about testing types.

QA Roles

Below are the most popular QA profile roles in an organization:

• Software test engineer
• Test analyst
• Test automation engineer
• Software development engineer in test (SDET)
• Test architect
• Test manager/ director

Read an excellent article with the top 30 manual testing interview questions and answers or you can watch this video.

Steps in the Manual Testing Process

Here is the general flow of activities that occur during the manual testing process:

• Understand the requirements/specifications.
• Create test cases and test scenarios.
• Execute test cases.
• Report and track bugs.
• Retest and perform regression testing after bug fixes.
• Provide test reports and feedback.

Manual Testing Skills

If you’re planning to begin your journey as a manual tester, then here are some skills that will help you get ahead:

• Attention to Detail: You need a sharp eye to catch small mistakes or issues that others might miss. For example, spotting a typo in an error message or noticing when a button doesn’t work as expected.
• Analytical Thinking: Be good at breaking things down and thinking logically. Imagine you’re testing an online shopping site. You’ll need to figure out all the different ways users might interact with it and plan your tests accordingly.
• Curiosity and Problem-Solving: Be curious like a detective! Ask questions like, “What happens if I click here?” or “What if I enter the wrong password?” If something goes wrong, you’ll need to dig into why it happened.
• Communication Skills: You’ll need to explain issues clearly, whether it’s writing bug reports or talking to developers. Use simple language and screenshots to show what went wrong and how to reproduce it.
• Understanding of Software Basics: You don’t need to be a programmer, but you should understand how software works at a basic level. For instance, knowing what databases and APIs can help you test better.
• Creativity: Think outside the box! Users don’t always follow the “correct” steps so you’ll need to imagine unusual ways they might use the software and test for those scenarios.
• Patience: Testing can be repetitive. You might have to run the same test multiple times to check if an issue is fixed or if the software still works after changes.
• Organizational Skills: You’ll deal with many test cases, bug reports, and deadlines. Staying organized ensures you don’t miss testing any critical feature.
• Collaboration Skills: You’ll often work with developers, product managers, and other testers. Being a team player and sharing feedback in a constructive way helps everyone build better software.
• Basic Knowledge of Test Tools: Learn to use tools like Jira (for bug tracking), Excel (for managing test cases), and maybe even browser developer tools (to check things like page errors or console logs).
• User-Centric Thinking: Always think from the user’s perspective. Ask, “Is this easy to use?” or “Does this make sense for someone who’s not tech-savvy?”

Few Myths About Manual Testing

Reality: Manual testing is essential for exploratory, ad-hoc, and usability testing, mainly when human intuition and an eye for detail are crucial.

Reality: With the right automation testing tools, you can achieve your testing ROI much faster than manual testing. Intelligent AI-powered test automation tools like testRigor help you create test steps in seconds using its generative AI engine. See the list of testRigor’s features.

Reality: Skilled and experienced testers play a vital role in manual testing. Their expertise and domain knowledge help identify complex issues, evaluate user interactions, and ensure a high-quality user experience.

Read more about QA myths and how testRigor is a test automation tool for manual testers.

Conclusion

“In many ways, being a good tester is harder than being a good developer because testing requires not only a very good understanding of the development process and its products, but it also demands an ability to anticipate likely faults and errors” – John D. McGregor.

An excellent manual tester should have analytical thinking, domain knowledge, documentation and communication, collaboration, and problem-solving abilities as skills. These skills collectively contribute to a manual tester’s ability to thoroughly test software, identify defects, and ensure a high-quality user experience.

While automation is becoming more prevalent, manual testing remains valuable, especially for tasks requiring human intuition, creativity, and a deeper understanding of user interactions.

“We spent so much time on maintenance when using Selenium, and we spend nearly zero time with maintenance using testRigor.”

Keith Powe VP Of Engineering - IDT