Manual Testing Tutorial for Beginners

Manual testing is considered the preliminary testing stage close to the software development. It assesses the app's behavior developed by carrying out the step-by-step evaluation of the requirement specification analysis. Manual testing is preferable for more minor projects because automation testing is expensive and needs extensive and detailed testing. Since agile has become standard practice, the latest demand is rising in the industry where developers expect to know about manual testing concepts. Hence, having a good understanding of manual testing is essential for developers as well as testing professionals. This Manual testing tutorial makes you an expert in manual testing concepts like SDLC, STLC, Bug life cycle, test cases, etc. It also includes the Roles and Responsibilities of a Manual Tester.

Rating: 4.5

Manual testing is a process of software testing in which we execute the test cases manually without using any automated testing tool. From the end user’s perspective, testers will execute the test cases manually. It tests whether the application is functioning as illustrated in the requirement document or not. It is one of the critical testing processes as it can detect both hidden and visible bugs of the software. The difference between the actual output and the expected output is called a bug.  

Manual testing software is compulsory for every recently built software before automation testing. Manual testing requires great time and effort, yet it gives a guarantee of bug-free software. So, to build a good career in Software testing you must learn Manual testing. 

If you want to learn manual testing, join our manual testing training. According to, the average salary of a manual tester in the US is around $112K per annum. In this manual testing tutorial for beginners, we will cover all the manual testing concepts in depth.  

Manual Testing Tutorial For Beginners

In this Manual Testing tutorial, we will start with the basics of Manual Testing and learn all the major Manual Testing concepts that a Manual Testing professional must be aware of. Now, let’s have a look at the components of this tutorial.

What is Manual Testing?

  Manual Testing is a kind of software testing in which a software tester develops and executes the test cases without using any automated testing tools. The main objective of manual testing is to detect the issues, bugs, and defects of a software application. Any new software application should be manually tested before performing the automation testing. The software testing fundamental “100% Automation is not possible” makes Manual Testing essential.

If you would like to become a Manual Testing-certified professional, then visit Mindmajix - A Global online training platform for the “Manual Testing” Course. This course will help you to achieve excellence in this domain.

Manual Testing Concepts

Need of Manual Testing

Whenever a software application is released into the market, it may have some issues or bugs, or end-users may face some problems while using it. So, we have to perform one testing stage to make the application stable and bug-free and deliver a quality software product to users. While performing the manual testing, the test engineer tests the software from the customer’s perspective to develop the appropriate test cases and give proper feedback to the developers.

Testing Methods

We have two types of testing methods, they are:

#1. Static Testing

Static Testing is also known as Verification. It is a method of verifying files and documents. It ensures that we are developing the correct product. It also verifies the requirements we have. In this method, test engineers will carry out activities like Reviews, Inspections, Walkthroughs, etc.

#2. Dynamic Testing

Dynamic Testing is also called Validation. It is a dynamic process of testing the software product. It validates whether the developed product is right or not.

How to do Manual Testing?

Follow these steps to do manual testing:

Step1: First, review all the documents related to the software, for selecting the testing areas.

Step2: Analyse all the required documents to get all the requirements mentioned by the end-user.

Step3: Build test cases as per the requirement document.

Step4: Execute all the test cases manually by using white-box testing and black-box testing.

Step5: If bugs are detected, report them to the development team.

Step6: When the developer fixes the bug, retest it. 

Learn and Practice MindMajix's Manual Testing Interview Questions and Answers

Advantages and Disadvantages: Manual Testing

Advantages of Manual Testing

  1. Manual testing detects almost every bug and issue of the software application.
  2. Through manual testing, software testers can access visual components like layout, text, and other components. They can also identify the UX and UI issues.
  3. It is suitable if we are making some unplanned changes to the applications as they can be adopted easily.
  4. As we do not use any high-level skills or type of tools, it will have a low cost of operations.

Disadvantages of Manual Testing

  1. The primary disadvantage of manual testing is it is time-consuming.
  2. Through manual testing, it is not easy to discover the color combination and size difference of the GUI objects.
  3. Performance testing and Load testing are impossible in manual testing.
  4. In Manual Testing, Regression test cases are time-consuming.
Do you know Manual Testing vs Automation Testing?

Roles and Responsibilities of a Manual Tester

Following are the roles and responsibilities of a Manual Tester:

  • Gathering and Analyzing the client requirements.
  • Establishing the test environment for executing the test cases.
  • Analyzing and Running the test cases.
  • Arranging Review Meetings.
  • Communicating with the users to understand the product requirements.
  • Interacting with the Test Manager.
  • Defect Tracking.
  •  Evaluating the testing results on bugs, errors, database impacts, and usability.
  • Preparing the reports on all the activities carried out while testing the software and reporting to design time.

 MindMajix YouTube Channel

Software Development Life Cycle(SDLC)

Software Development Life Cycle(SDLC) is a mechanism that is followed in software projects for systematically developing a software product and delivering a good product. It intends to create a high-quality product that satisfies or surpasses the customer expectations, works efficiently and effectively in the planned and current IT infrastructure, and is economical to cost-efficient and maintain for enhancement. In Software Development Life Cycle, we will have the following phases:

SDLC (Software Development Life Cycle)

#1 Requirements Phase

The requirements phase is the first step of SDLC. The business analyst gathers the requirement from the client or customer as per the requirements of the client and documents them in the Business requirement specification document.

#2. Analysis Phase

After requirement analysis and gathering is completed, the next phase will be defining and documenting the product requirements and getting approval from the customers. 

#3. Design Phase

The design phase has two steps, they are:

  • High-Level Design(HLD): It provides the architecture of software products to be built on and is performed by senior developers and architects.
  • Low-Level Design(LLD): It is performed by senior developers. It explains how every feature of a product must work and how every element must work. In this phase, we will carry out only designing work.
  • The output of this phase is a Low-level document and a High-level document, which acts as input to the next phase.

#4. Development Phase

Developers of all levels(Freshers, Juniors, and Seniors) are actively involved in this phase. In this phase, we will start developing the product and begin writing the code for the software. Source Code Document(SCD) and the product is the output of this phase.

#5. Testing Phase

After completing the software development, developers will send the product to the testing team. They will test it thoroughly to identify the defects. They either test the software manually or use automated testing tools. It ensures that every element of the software works properly.

#6. Maintenance & Deployment Phase

After completing the testing, we will deploy and deliver the product to our customers. Implementation/Deployment engineers will deploy the product. When the customers begin using the software product, then real problems will arise and have to be resolved from time to time.

SDLC Models

We have various SDLC models that are used during the software development process. These models are also known as software development process models. Following are some of the SDLC models adopted in the industry:

#1. Waterfall Model

The waterfall model is a conventional software development model. It follows a sequential design process, in which the development is viewed as streamlined downwards like a waterfall, through different steps like requirement gathering, Feasibility Analysis/Study, designing, coding, testing, deployment, and maintenance. Every next phase starts only after the objective of the previous phase is completed. This model is better for short-term software projects where quality is more important than the schedule or cost.

#2. V Model

The V-model is also called the Verification & Validation model. In this model, every phase of the SDLC model should be completed before the next phase begins. It also follows the sequential design process similar to the waterfall model.

#3. Spiral Model

The spiral model is an iterative development model. It is a mixture of both the linear development processes and the prototype development processes. This model focuses more on risk analysis. Mostly, this development model is adopted by complicated and large projects where risk is very high. 

#4. Agile SDLC

The Agile Scrum methodology is a popular agile software development method. It is a blend of both iterative and incremental models for handling product development.

#5. Prototype

It is one of the most commonly used SDLC models. In this model, a prototype model is built before the actual product. Generally, the software development team will use this model when end users don’t know the requirements in advance.

STLC(Software Testing Life Cycle):

STLC(Software Testing Life Cycle) is a process that identifies which test activities to perform and when to execute those test activities. Even though testing varies between organizations, there is a testing life cycle. Following are the different phases of STLC:

STLC ( Software Testing Life Cycle)

#1. Requirement Analysis

The entry benchmark for this is the Business Requirement Specification(BRS) document. In this phase, the testing team analyzes the requirements from the testing perspective. This phase identifies whether we can test the requirements or not. If any requirement is not testable, the testing team has to interact with different stakeholders like System Architects, Business Analysts, Technical Leads, etc.

#2. Test Planning

It is the first phase of the software testing process. Generally, in this phase, the test lead/test manager involves evaluating the efforts and budget projections of the complete project. According to the requirement analysis, the test preparation is done. In this phase, activities like tools selection, resource planning, deciding roles and responsibilities, and training news are performed.

#3. Test Design

In this phase, the testing team develops the test cases. Testers develop test scripts and test cases. When the test cases are ready, they are reviewed by the team leads or peer members. 

#4. Test Environment Setup

We can begin this phase in parallel with the test designing phase. The testing environment setup is performed according to the software and hardware requirement list. Sometimes, the testing team may not be engaged in this phase. The customer or development team gives the testing environment.

#5. Test Execution

According to the planned test cases, the testing team begins executing the test cases. After determining the test case result, it must be updated in test cases. The defect report should be developed for the failed test cases and submitted to the development team with a bug-tracking tool to fix the defects. After fixing the defect, retesting will be performed.

#6. Test Closure

The final stage of the Software Testing Life Cycle(STLC) is Test Closure. In this stage, we will prepare the Test Metrics and Test Closure Report. The testing team will meet to assess the cycle completion criteria according to the Test coverage, cost, quality, business objectives, and software. The testing team analyzes the test artifacts for identifying the strategies that must be implemented in the future.

Are you planning to build a career in Manual Testing? Sign up for this Manual Testing Certification Training in Hyderabad to begin your journey today!


Basis of Comparison




SDLC is mainly connected to software development, which indicates that it is the process of developing a software application. 

STLC is primarily connected to software testing, which indicates that it is the process of testing software.


The full form of SDLC is the Software Development Life cycle.

The full form of STLC is the Software Testing Life cycle.


In the Software development process, a large number of developers will take part.

In the Software testing process, a small number of testers will be involved.


The aim of SDLC is to finish the development of software.

The aim of STLC is to complete the software testing.


SDLC is useful to develop a good quality software product.

STLC is useful to make the software bug-free.

Designing Phase

According to the requirement analysis, the software development team will build the Low-Level Design(LLD) and High-Level Design(HLD) of the software.

In STLC, the Test Lead or Test Architect will plan the test strategy.

Coding Phase

In SDLC coding phase, the software developer starts writing the code according to the designed document.

In STLC, the QA team develops the test scenarios for authenticating the product quality.

Testing Phase

In the SDLC testing phase, the software testers will carry out different kinds of testing like integration testing, unit testing, integration testing, etc. The development team will fix the bugs and report them to the tester.  

As per the test cases, the tester will perform one round of system and integration testing. While doing the testing, if they detect any bugs, it will be reported and resolved after retesting.

Types of Manual Testing

Types of Manual Testing

The following are the types of manual testing:

#1. White box testing:

It is also known as Clear box, Structural, and Glass box testing. In this type of testing, testers will use the system’s internal perspective and programming skills to design the test cases. Generally, this testing is performed at the unit level.

#2.Black box testing:

In black-box testing, testers assess the functionality of the software application without considering the internal code structure. Black box testing can be applied to all levels of testing like Integration, Unit, Acceptance, and System testing.

#3. Acceptance Testing:

Acceptance testing is also known as pre-production testing. Along with the testers, end-users will also perform this testing for validating the functionality of the application. After completing the acceptance testing successfully, formal testing is conducted to decide whether the application is built according to the requirement. 

#4. Unit Testing:

Unit testing is also known as Component testing or Module Testing. It is carried out to verify whether a particular module or unit of the code is working properly. It is performed by the developers in their environment.

Related Article: Types of Unit Testing

#5. System Testing:

System testing is a process of testing the completely integrated application for assessing the system’s comfortability with its defined requirements known as System testing or End to End testing. It verifies the entire system to ensure that the application works as planned or not.

#6. Integration Testing:

Integration testing is a mechanism of testing the software between two software modules. Integration testing is performed by various approaches called the Top-Down approach, Bottom-Up approach, and Big Bang Approach.  

Manual Testing Tools

#1. Jira

It is one of the leading companies handling tracking program issues. Due to its comfortable framework and personalizable features, Jira is good as a management tool. Working on Java is simple, yet at the same time complex, according to the user and type of operation.

#2. Trello

Trello is popular for its comfortable project management and efficient tracking of issues. Testers have the liberty of creating the problems available with a convenient-to-use setup that can be further developed through some complex automation rules.

#3. Zephyr

Zephyr antique spreadsheets, most accurately when integrated with Jira. It improves the visibility of the test results by providing a well-organized layout plan, ideal for most build types.

#4. Sauce Labs

It is not only comprehensive, but also it is one of the tools that emphasize a clean background demonstrated intuitive for the users. It provides constant cross-browser testing throughout a wide variety of devices and browsers. The distinct feature is feedback loop integration, which allows rapid and efficient exchanges across the development cycle.

#5. Browser Stack

This testing kit is famous and preferred for its rapid loading of live applications to real-world browsers, which preserves real-time. Even though the pages are not entirely operative, they will show the critical and required functions.

#6. Bugzilla

It is an essential and widely used bug-tracking tool. It tracks the bugs and prepares the bug report. We can also use it as a test management tool. We can easily connect it with other test case management tools like quality center, ALM, etc.

#7. MantisBT

The MantisBT refers to the “Mantis Bug Tracker”. It is an online-based bug-tracking system, and it is also a freeware tool. It follows the software bugs and is implemented in the PHP programming language. 

Bug Life Cycle

What is a Bug?

A bug is an error or a flaw of an application that limits the general flow of the application by differing the expected behavior of the application from the actual behavior. The defect takes place when the developer makes a fault while building the application, and when the tester detects this flaw, it is called a defect or bug.

What is the Bug Life Cycle?

The bug life cycle is also known as the defect life cycle, is a bug life cycle that goes through different stages in its life. This life cycle begins once the tester discovers any new bug and ends when the tester marks it as fixed.

Bug Workflow

Following are the different states of the Bug life cycle:

  1. New: This is the first state of the bug life cycle. When the tester finds a new bug, it immediately falls into a “New” state, and in the later stages of the bug life cycle, testing and validation are performed on this bug. 
  2. Assigned: In the Assigned stage, the project lead or project manager of the testing team will assign the newly found bug to the development team to work on the bug.  
  3. Open: In this stage, the developer begins analyzing the bug and fixing it. If the developer finds it inappropriate, it will be moved to four states, namely Deferred, Duplicate, Not a Bug, and Rejected- according to a reason.
  4. Fixed: After fixing the bug by making the changes, the developer marks the status of the bug as “fixed.”
  5. Retest: In this stage, the tester retests the bug for verifying if the defect is fixed correctly by the developer based on the requirements or not.
  6. Reopen: If an issue remains in the bug, then the testing team will assign it to the developer again to test and change the status of the bug to “Reopen.” 
  7. Verified: If the tester does not detect any issue in the bug after assigning it to the developer for retesting and if he senses that the bug has been fixed correctly, then he will mark the bug’s status as “Verified.”
  8. Closed: When the bug is no longer available, then the tester changes the bug’s status to “Closed.”
  9. Duplicate: If the developer discovers the bug-like any other bug or if the concept of the bug matches with any other bug, then the developer changes the bug’s status to “Duplicate.”
  10. Rejected: If the developer does not consider the bug as a genuine bug, then he will mark it as “Rejected.”
  11. Not a Bug: If the bug does not affect the functionality of the application, then its status changes to “Not a Bug.”
  12. Deferred: If the developer senses that the bug is not of very critical priority and it can be fixed in the subsequent releases, he changes the bug’s status as “Deferred.”

Manual Testing Test Case

Test Case Template

The test case is a set of conditions under which a tester evaluates whether the software application gives the desired results. Test case development involves case names, pre-conditions, expected results, and input conditions. A test case is the first stage of action and originated from the test scenarios. It is an in-detail document that provides detailed information about the testing process, testing strategy, expected output, and pre-conditions. 

Testers execute them in the testing process for checking whether the application is doing the work for which it was built or not. It also helps the tester in bug reporting by connecting the bug with the test case ID. The test case documentation serves as absolute proof for the testing team because if the developer misses something, then we can catch it during the execution of these test cases. 

When do we develop a test case?

We will develop the test cases when we get the below:

  • When the client provides the business requirements, then the developer begins developing and tells them that they require 3.5months for building this product.
  • In the meanwhile, the testing team will begin developing the test cases.
  • After completing the test case development, testers will send the test case document to the test lead for review.
  • When the developers complete building the product, it is delivered to the testing team.

Why do we develop the test cases?

We build the test cases due to the following reasons:

  • For maintaining consistency in the test case execution.
  • To ensure better test coverage.
  • For avoiding training to every new software tester on the product.
  • It relies on the process instead of a person.

Test case template

Following are the fields of the test case development:

  • Test case type: The test case can be a system, integration, or functional test case. It can also be a positive or negative test case.
  • Step number: It is a critical field because if step number 10 is failing, we can report it and prioritize working and also determine if it is an essential bug.
  •  Pre-condition: Pre-conditions are the required changes that must be satisfied by all the test engineers before beginning the test execution process. 
  • Test data: Test data is the input or the values we have to create based on the pre-condition.
  • Severity: In the test case, the severity field discusses the importance of a particular test case. The test execution process relies on the severity of test cases. The severity can be Minor, Major, and Critical. We can select the severity values as per the module. 

API Testing 

What is API Testing?

API testing is a software testing type that tests Application Programming Interfaces(APIs). The main objective of API testing is to verify the functionality, security, performance, and reliability of programming interfaces. By using both manual testing and automation testing, we can do API testing. In the API testing, rather than using the conventional user inputs and outputs, we use software tools for sending the calls to API and getting output. 

What is API Testing

Importance of API Testing

API Testing is an important task that the testers must emphasize. It provides various advantages over other types of testing. The following are the advantages of API testing:

  1. GUI Independent: We can perform API testing for checking the essential functionality of an application to reveal tiny errors and to determine a product’s strength. Moreover, we can test the APIs without the graphical user interface.
  2. Language Independent: Through JSON or XML, we can interchange the data, therefore we can use any language for automation, irrespective of the languages utilized for building the application. 
  3. Reduce Testing Cost: Through API Testing we can detect small bugs before GUI testing. Generally, these small bugs will grow bigger in the GUI testing. Therefore detecting those bugs while doing the API testing will be cost-efficient.
  4. Improved Test Coverage: Almost every API has features that enable the tester for creating automated tests with great test coverage including negative and positive cases. We can hardly discover the test cases that we cannot automate.
  5. Enables faster releases: The test cases that take approximately 8to10hours while running the UI regression testing but, they will take only 1to2hours while doing API testing.

Types of API Testing

The following are the types of API testing:

  • Functionality Testing: To check whether the API works and performs exactly what it should do.
  • Validation Testing: It tests the aspects of the behavior, efficiency, and product of an API.
  • Reliability Testing: It tests if the API can be constantly linked and generate constant results.
  • UI Testing: It includes user interface testing for API and other fundamental elements.
  • Load Testing: Load testing assures the performance of the API in both normal and peak conditions.
  • Security Testing: It tests if the API is safe against all possible threats.

API Testing Tools

For successfully doing API testing, we require a tool for structuring and handling our test cases. Following are some of the most widely-used API testing tools:

  • Postman: Postman is used by more than 4 million users worldwide. Postman runs on Windows, Mac, Chrome, and Linux. It enables us to establish all the cookies and headers your API anticipates, and then verify the response.
  • SoapUI: It is the most famous and freeware API testing tool. Through SoapUI we can do performance testing, functional testing, data-driven testing, and security testing. It will offer the reports to test and enables you to export the data.
  • REST-assured: It is a freeware Java DSL(Domain-Specific Language) tool that simplifies Rest service testing. It supports JSON and XML requests. 
  • Katalon Studio: It is a strong and extensive automation tool for Web, Mobile, and API testing. It offers simple deployment by including all the ALM integrations, plugins, and frameworks in one package.

How do we perform API Testing?

Performance of API Testing

By following the below steps we can perform the API testing:

#1. API Specification Review:

The first step of API testing is documenting the requirements of the API testing. The API testing requirements will be: 1) What is the use of API? What is the workflow of the application? What are the characteristics of API? By documenting these API testing requirements, we can plan the API tests.

#2. Establish the Test Environment:

The second of API testing is establishing the test environment, with the essential group of parameters about the API. This includes configuring the server and database for application requirements.

#3. Integrating the application data:

In this phase, we have to merge our application data with the API tests to assure that the API works as anticipated.

#4. Determining the kind of API Testing:

After creating the testing requirements and boundaries, we have to determine what we have to test our API for. We have different kinds of API testing like validation testing, functionality testing, security testing, load testing, and end-to-end testing. 


As every test case cannot be automated, manual testing is an essential software testing process. This manual testing tutorial provides you with a detailed understanding of the manual testing procedure, manual test cases, and manual testing tools. I hope this article helps you advance your manual testing skills. If you have any queries, let us know by commenting in the below section. 

Join our newsletter

Stay updated with our newsletter, packed with Tutorials, Interview Questions, How-to's, Tips & Tricks, Latest Trends & Updates, and more ➤ Straight to your inbox!

Course Schedule
Manual Testing TrainingApr 16 to May 01View Details
Manual Testing TrainingApr 20 to May 05View Details
Manual Testing TrainingApr 23 to May 08View Details
Manual Testing TrainingApr 27 to May 12View Details
Last updated: 14 Nov 2023
About Author

Ravindra Savaram is a Technical Lead at His passion lies in writing articles on the most popular IT platforms including Machine learning, DevOps, Data Science, Artificial Intelligence, RPA, Deep Learning, and so on. You can stay up to date on all these technologies by following him on LinkedIn and Twitter.

read more
Recommended Courses

1 / 15