Manual Testing Tutorial for Beginners

Due to the tremendous increase in use of Mobile Applications, Software Testing has evolved as one of the most lucrative markets. As per Global Market Insights, it is expected to grow at the rate of 5% CAGR from 2023 to 2024. Not only this, the demand for Manual Software Testers is also rising due to the fact that ‘100% Automation is not possible.’ Thus, organizations expect developers and testing professionals to know about Manual Testing concepts to follow Modern Agile Practices. 

The average salary for Entry Level Manual Testing is around USD 60,000 in the US, according to Zippia Statistics. Hence, if you are thinking of choosing Manual Testing as the career option, the market is ready to welcome you with various opportunities. So with this blog, clear all your queries about Manual Testing concepts and build your career! 

Table of Contents

• Overview of the Manual Testing
• Why do we need Manual Testing? 
• Primary Skillset for Manual Testing
• Secondary Skillset for Manual Testing
• Roles and Responsibilities of the Manual Testers
  • Entry Level(1-2 years)
  • Mid-Level (3-5 years)
  • Senior Level (8-10 years) 
• Manual Testing Concepts 
  • Static Testing 
  • Dynamic Testing 
  • What is a Bug? 
  • Bug Lifecycle
  • What is a Test Case? 
  • Format of Test Case in Manual Testing
• What is STLC? 
• SDLC Vs STLC
• Types of Manual Testing 
• Tools for Manual Testing 
• API Testing 
  • Importance 
  • Types
  • Tools for API Testing 
  • How to perform the API Testing?
• Frequently Asked Questions

Overview of the Manual Testing

Software Testing tells us how the app, developed as per the requirement specification analysis will behave in real time. It generally has two types namely Automation Testing and Manual Testing. For Automation Testing, you can use various tools and frameworks to test the application. But in Manual testing, we execute the test cases manually without using any automated testing tool. 

Thus, testers will execute the test cases that have been designed from the end user’s perspective. The main objective of manual testing is to detect the issues, bugs, and defects of a software application.

To advance your career as a Manual Tester, consider enrolling in the "Manual Testing Training" course provided by Mindmajix.

Why do we need 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. Therefore, 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.

But before moving on to Manual Testing, let us look at the Primary Skillset that you need to learn Manual Testing. 

Primary Skillset to Learn for Manual Testing

• You should have the basic understanding of how the application is built, Operating Systems, Web Browsers, etc. 
• You should know about the Software Development Lifecyle, the role of Manual Testing in the SDLC, and how it fits into the overall process 
• You must have Basic Documentation skills so that you can manage the test plan, test case, test scenario, and test script documentation.
• You should be familiar with Modern Software Engineering techniques like Agile and DevOps, and their impact on testing practices.

Once these primary skillset are marked as done in your learning goals, you are ready to dive deep into the Manual Testing concepts! Before moving forward let’s see a secondary skillset and responsibilities for you to become an expert in Manual Testing. 

Secondary Skillset to Learn for Manual Testing

Other than the primary skillset another factor that matters is the secondary skillset for becoming a Manual Testing Expert. We can also call them the complementary skillset that is required to grow our career as a Manual Testing Expert. Let us have a look at them. 

• Understanding of Automation Testing: Developing knowledge of automation testing tools and frameworks like Selenium, Appium, or TestNG to complement manual testing efforts.
• Proficiency in Test Management Tools: Learning to use test management tools such as Jira, TestRail, or HP ALM for test case management, execution tracking, and defect reporting.
• Familiarity with version control systems: and databases:  Having a good understanding of Version Control tools like Git or SVN helps us to manage test scripts, collaborate with team members, and track changes effectively. Also, understanding basic database concepts and SQL queries allows us to validate data integrity, perform backend testing, and troubleshoot database-related issues.
• Understanding of Web Technologies: Gaining knowledge of web technologies such as HTML, CSS, and JavaScript can help us understand web application architecture and conduct browser compatibility testing.

Roles and Responsibilities of the Manual Testers

Entry Level (1-2 years)

• At the Entry Level, testers follow requirements closely, break them down into testable scenarios, and document them systematically.
• When reporting defects, they provide detailed steps to reproduce, screenshots if necessary, and prioritize them based on severity and impact.
• They also perform regression testing that involves rerunning existing test cases to ensure that recent changes haven't introduced new defects or impacted existing functionality.
• They update team members on test progress regularly, participate in meetings, and provide clear, concise test reports.

Mid-Level (3-5 years)

• At this level, Test planning involves understanding project goals, identifying risks, and creating a detailed test strategy with a focus on optimizing resource allocation.
• They have experience with test automation tools like Selenium and have developed scripts for repetitive tasks, focusing on maximizing test coverage.
• They also implement Performance testing which involves simulating real-world scenarios to assess system behavior under load, using tools like JMeter or Gatling.
• They provide guidance and foster a collaborative environment to support team growth.

Senior Level (8-10 years) 

• They are well-versed in testing methodologies such as Agile and Waterfall, adapting them based on project requirements and team preferences.
• At this stage of Manual Testing Expertise, the Quality assurance efforts extend beyond testing, involving process improvement initiatives, such as implementing CI/CD pipelines or refining test automation frameworks. 
• They work closely with cross-functional teams to ensure alignment with project objectives and quality standards.
• They are also involved in identifying complex testing challenges by analyzing root causes, consulting with stakeholders, and making data-driven decisions.

Manual Testing Concepts 

Let us start with the basic concepts in Manual Testing and why they are important for the entire Testing Process for our Application. This will help us to deliver the best-in-class software to the end-users. 

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. The main objective of this type of testing is to check the correctness of factors like code, design documents, and requirements specifications. 

Dynamic Testing 

Dynamic Testing is also called Validation which deals with testing the software product. It validates whether the developed product is right or not. In other words,  Dynamic Testing is a dynamic and interactive process where test cases are executed against the software under test (SUT), and the actual outcomes are compared with expected results. 

Now, the main objective of both these techniques is to find the bug in the software. Let us see what the Bug is. 

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. 

To detect the bug, we have to implement the Bug Lifecycle and Bug Workflow. 

Bug Lifecycle and Workflow

You might get confused with the Bug Lifecycle and the Bug Workflow. Thus, it is important to clearly understand both the concepts. 

The bug or the defect life cycle is the sequence of stages that the bug goes through it is its life. This life cycle begins once the tester discovers any new bug and ends when the tester marks it as fixed.  On the other hand, the Bug Workflow is the set of activities that are performed within those stages. 

Following are the different states of the Bug life cycle:

• 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.
• 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.  
• 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.
• Fixed: After fixing the bug by making the changes, the developer marks the status of the bug as “fixed.”
• Retest: In this stage, the tester retests the bug to verify if the defect is fixed correctly by the developer based on the requirements or not.
• 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.” 
• 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.”
• Closed: When the bug is no longer available, then the tester changes the bug’s status to “Closed.”
• 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.”
• Rejected: If the developer does not consider the bug as a genuine bug, then he will mark it as “Rejected.”
• Not a Bug: If the bug does not affect the functionality of the application, then its status changes to “Not a Bug.”
• 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 to “Deferred.”

After we have identified the bugs in the source code of our application, we have to write the test case which is covered in the next section. 

What is a Test Case?  

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 originates 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 to check 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. You might think about how we write the Test Case in the Manual Testing. So, let us cover this now. 

Format of Test Case in Manual Testing

• 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, or Critical. We can select the severity values as per the module. 

It’s now time to learn about the entire process of the Software Testing Life Cycle. 

What is 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:

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.

Test Planning: This is the first phase of the software testing process. Generally, in this phase, the test lead/test manager is involved in 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 tool selection, resource planning, deciding roles and responsibilities, and training news are performed.

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. 

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.

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.

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 to identify the strategies that must be implemented in the future. 

SDLC Vs STLC

Basis of Comparison	SDLC	STLC
Definition	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.
Full-Form	The full form of SDLC is the Software Development Life cycle.	The full form of STLC is the Software Testing Life cycle.
Participants	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.
Aim	The aim of SDLC is to finish the development of software.	The aim of STLC is to complete the software testing.
Use	SDLC is useful for developing 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 the 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, they will be reported and resolved after retesting.

 

Types of Manual Testing 

The following are the types of manual testing:

Manual Testing Types 

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.

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.

Acceptance Testing: Acceptance testing is also known as pre-production testing. Along with the testers, end-users will also perform this testing to validate 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 requirements. 

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.

System Testing:

System testing is a process of testing the completely integrated application to assess 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.

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.  

Tools for Manual Testing 

Jira(Version: 9.14.1): 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 Jira is simple, yet at the same time complex, according to the user and type of operation.

Trello(Version: 2.12.3): 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.

Zephyr: Zephyr is a test management tool that can be integrated with Jira. It improves the visibility of the test results by providing a well-organized layout plan, ideal for most build types.

Sauce Labs: This tool provides constant cross-browser testing throughout a wide variety of devices and browsers. Its distinct feature is feedback loop integration, which allows rapid and efficient exchanges across the development cycle.

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.

Bugzilla(Version:5.0.6): 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.

MantisBT(Version:2.26.1): 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. 

Downloading these latest releases of Manual Testing Tools will help you to excel in your testing journey, Now let’s understand API Testing.

API Testing 

As you are aware of the Manual Testing concepts, let us also see when the applications are exposed as the Application Performance Interface (API), and how to test them. This comes under API Testing. The main objective of API testing is to verify the functionality, security, performance, and reliability of programming interfaces. 

Application Programming Interface (API ) 

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. 

Importance 

• API Testing is GUI independent: We can perform API testing to check 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.
• It is 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. 
• API Testing Reduces Overall 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.
• Test Coverage is improved: Almost every API has features that enable the tester to create automated tests with great test coverage including negative and positive cases. We can hardly discover the test cases that we cannot automate.
• It enables faster releases: The test cases take approximately 8 to 10 hours while running the UI regression testing but, they will take only 1 to 2 hours while doing API testing.

Types of API Testing 

• Functionality Testing: It is used 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.

Tools for API Testing 

• 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 enable 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 to perform the 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: 

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

1. Establish the Test Environment: The second step 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.
2. Integrating the application data: In this phase, we have to merge our application data with the API tests to ensure that the API works as anticipated.
3. 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, which we have already discussed in the above sections. 

Process of API Testing

After learning about the fundamentals of Manual Testing, let us now see what are the roles and responsibilities of a Manual Tester. 

Frequently Asked Questions

When should we use the Smoke and Adhoc Testing? 

Smoke testing is used at the beginning of the testing cycle to quickly assess whether critical functionalities of the software are working as expected. But the Adhoc Testing is used throughout the testing process to explore the software intuitively and uncover defects that may not be captured by predefined test cases. 

How does the JMeter work? Does it add records to the application in real-time?

JMeter tests the application on the HTTP Protocol level. When we configure the JMeter within our Testing Environment, it sends the HTTP requests just like the real browser. If you want to see the request and response details, you have to add the View Results Tree to your test plan. Thus, you can easily test the application. 

Is Manual Testing a Good Career for Freshers? 

Manual testing roles often have lower entry barriers compared to automation testing, making it more accessible for newcomers to the industry. Thus, they are good career choices for the Freshers. With continuous learning and experience, freshers can transition into specialized areas of testing or move into automation testing roles and advance their careers. 

What kind of projects can we mention in the resume for Manual Testing? 

For mentioning the projects in the resume as the Manual Tester, you can include the test plan for the web application testing, mobile application testing, API Testing, etc. Also, you can mention the projects related to the Agile and Scrum environments. In this, you can mention the test plan that you created during the sprint planning and reviews. 

Do I need to learn Selenium for Manual Testing? 

Selenium is primarily an automation testing tool used for web applications. Therefore, you do not need to learn it as a Manual Tester. However, learning selenium can help you to explore career opportunities in automation testing roles. Also, you can save a lot of time which gets consumed by performing repetitive tasks. 

What are the challenges in Manual Testing as a career? 

The main challenge in Manual Testing is the time-management. This happens when dealing with large and complex software systems. Testers need to manage their time efficiently to meet project deadlines due to which time management becomes a challenge. Also, it is difficult to extend the limited scope of Manual Testing as most of the tasks today tend to be automated. 

Conclusion 

Let us pile up what we have covered till now. 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. We have also covered API Testing, its process, roles, and the secondary skillset required to ace our career as a Manual Testing expert. We hope this article helps you advance your manual testing skills. If you have any queries, let us know by commenting in the below section.