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 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.

Testing Terms You Should Know

Here are a few popular testing terminologies which 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 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 Name-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.

Step 10: Close the browser.

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 (Testing Pyramid)

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 is tested.
• System Tests: The whole system is combined and tested as a single unit.
• Acceptance Tests: 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.

Few Myths Debunked

1. Myth: Manual testing is outdated and requires no skills.
   Reality: Manual testing is essential for exploratory, ad-hoc, and usability testing, mainly when human intuition and an eye for detail are crucial.
2. Myth: Manual testing is cheaper, while automation is expensive.
   Reality: With the right automation testing tools, you can achieve your testing ROI much faster than with manual testing. Using a modern AI-powered test automation tool such as testRigor enables teams cover the functionality fast, and spend very little time on test maintenance. The added capability of creating test steps in seconds with testRigor’s generative AI engine further enhances efficiency.See the full list of testRigor’s features.
3. Myth: Manual testing is only for novices and beginners.
   Reality: Skilled and experienced testers play a vital role in manual testing. Their expertise and domain knowledge helps identify complex issues, evaluate user interactions, and ensure a high-quality user experience.

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.