Getting everything ready for you…

Loading courses, problems and your progress. This takes just a moment.

0s

Guides › Software Testing & QA

Manual Testing: Complete Guide with Examples

Learn manual testing from basics to advanced, including test cases, test scenarios, bug reporting, real-world examples, and best practices.


title: "Manual Testing: Complete Guide with Examples" slug: "manual-testing-complete-guide" description: "Learn manual testing from basics to advanced, including test cases, test scenarios, bug reporting, real-world examples, and best practices." seoTitle: "Manual Testing Guide with Examples for Beginners | Codify" category: "Software Testing & QA" emoji: "📝" difficulty: "Beginner to Intermediate" tags: - Manual Testing - Software Testing - QA Testing - Test Cases - Bug Reporting estimatedReadTime: "12–15 minutes"

Manual Testing: Complete Guide with Examples

Manual testing is one of the most important skills in software quality assurance (QA). It helps testers verify that an application works as expected by interacting with it manually, without relying on automated test scripts.

Whether you are a beginner learning software testing or preparing for a QA engineer job, understanding manual testing will help you identify bugs, improve user experience, and build reliable software.

In this guide, you will learn manual testing fundamentals, testing types, test scenarios, test cases, bug reporting, real-world examples, and best practices.

Table of Contents

  1. What Is Manual Testing?
  2. Why Is Manual Testing Important?
  3. Manual Testing vs Automation Testing
  4. How Manual Testing Works
  5. Software Testing Life Cycle
  6. Types of Manual Testing
  7. Test Scenario vs Test Case
  8. How to Write Test Cases
  9. Test Case Examples
  10. Bug Reporting and Defect Life Cycle
  11. Severity vs Priority
  12. Real-World Testing Example
  13. Manual Testing Tools
  14. Manual Testing Best Practices
  15. Common Mistakes to Avoid
  16. Practical Exercises with Solutions
  17. Manual Testing Interview Questions
  18. Career Roadmap
  19. Frequently Asked Questions

1. What Is Manual Testing?

Manual testing is a software testing process in which a tester executes test cases manually to verify that an application behaves according to its requirements.

The tester interacts with the application like a real user and checks whether features work correctly.

For example, when testing a login page, a tester may:

If the application behaves differently from the expected result, the tester investigates and reports the issue.

Key Characteristics

Important: Manual testing does not mean testing without a plan. Effective manual testing requires clear objectives, test cases, suitable test data, and proper documentation.

2. Why Is Manual Testing Important?

Manual testing helps teams find functional problems and usability issues before software reaches users.

Main Benefits

1. Better user experience

Testers can evaluate whether an application feels intuitive and easy to use.

2. Exploratory testing

Testers can investigate unexpected behaviors that may not be covered by predefined test cases.

3. Early defect detection

Testing during development can reveal problems before they become more expensive to fix.

4. Flexible testing

Manual checks can be adjusted quickly when requirements change.

5. Visual verification

Testers can inspect layouts, text, colors, spacing, and other visual elements.

6. Real-world user perspective

Testers can try unusual workflows and identify confusing interactions.

Limitations

Manual testing also has limitations:

The best approach depends on the application, risks, budget, and testing goals.

3. Manual Testing vs Automation Testing

Manual testing relies on human execution, while automation testing uses scripts or tools to execute checks.

Feature Manual Testing Automation Testing
Execution Performed by a tester Performed by scripts or tools
Initial setup Usually simpler Requires setup and scripting
Repeated tests Can be time-consuming Often faster after setup
Exploratory testing Very useful Limited without human guidance
Visual and usability review Strong for human judgment Can support specific visual checks
Large regression suites May require substantial time Often suitable
Maintenance Test documentation needs updates Scripts also need maintenance
Best use Exploration and usability Repetitive, predictable checks

Which One Should You Learn First?

Start with manual testing fundamentals because they teach you how to understand requirements, identify risks, design test cases, and report bugs.

After that, learn automation tools such as Selenium or Playwright to improve your testing capabilities.

Manual and automated testing complement each other; neither replaces every use case of the other.

4. How Manual Testing Works

A typical manual testing workflow includes the following steps.

Step 1: Understand the Requirements

Read the product requirements, user stories, acceptance criteria, and design documents.

Example requirement:

"A registered user must be able to log in using a valid email address and password."

Step 2: Identify Test Scenarios

Determine what needs to be checked.

Examples:

Step 3: Create Test Cases

Write detailed steps, test data, and expected results for each scenario.

Step 4: Prepare the Test Environment

Ensure that the application, browser, test account, database, and other required resources are available.

Step 5: Execute Test Cases

Follow the documented steps and record the actual results.

Step 6: Report Defects

If actual behavior differs from expected behavior, record the issue with clear reproduction steps and supporting evidence.

Step 7: Retest Fixes

After a developer fixes a bug, repeat the relevant test to confirm that the issue is resolved.

Step 8: Perform Regression Testing

Check related features to ensure that the change has not introduced new problems.

5. Software Testing Life Cycle (STLC)

The Software Testing Life Cycle, or STLC, describes the activities performed during the testing process.

1. Requirement Analysis

Understand the requirements and identify what can be tested.

2. Test Planning

Define the testing scope, strategy, schedule, resources, risks, and responsibilities.

3. Test Case Development

Prepare test cases, test data, and supporting documentation.

4. Test Environment Setup

Configure the environment required to execute tests.

5. Test Execution

Run test cases and record pass or fail results.

6. Defect Reporting and Tracking

Document defects and monitor them until an appropriate resolution is confirmed.

7. Test Closure

Summarize testing results, unresolved risks, defect statistics, and lessons learned.

These phases may overlap, repeat, or be adapted depending on the team's development process.

6. Types of Manual Testing

6.1 Functional Testing

Checks whether application features work according to requirements.

Example: Verify that clicking Add to Cart adds the selected product to the shopping cart.

6.2 Smoke Testing

A quick set of checks to determine whether the main functions of a new build work well enough for further testing.

Example: Verify that the application launches, users can log in, and the dashboard opens.

6.3 Sanity Testing

A focused check of a particular change or affected area to determine whether it works as intended.

Example: After a password-reset fix, verify the updated password-reset flow.

6.4 Regression Testing

Checks existing functionality after code changes to ensure previously working features have not broken.

Example: After updating checkout, verify that login, cart updates, payment, and order confirmation still work.

6.5 Retesting

Repeats a previously failed test after the reported defect has been fixed.

Example: If the Login button previously did nothing, repeat the original test after the fix.

6.6 Exploratory Testing

Combines learning, test design, and execution. The tester explores the application and investigates interesting behavior without relying only on predefined cases.

Example: Try unusual combinations of filters, navigation, and browser actions on a shopping website.

6.7 Usability Testing

Evaluates whether the application is easy to understand and use.

Example: Check whether a new user can find the registration form without assistance.

6.8 Compatibility Testing

Checks whether the application works across supported browsers, operating systems, devices, and screen sizes.

Example: Verify a website in Chrome, Firefox, and Safari where supported.

6.9 User Acceptance Testing (UAT)

Business stakeholders or intended users verify that the application meets their needs and acceptance criteria.

Testers may support UAT, but the business or product stakeholders generally determine acceptance.

7. Test Scenario vs Test Case

These terms are related but serve different purposes.

Test Scenario

A high-level statement describing what needs to be tested.

Example: Verify the login functionality.

Test Case

A detailed set of steps, input data, and expected results used to verify a specific behavior.

Example:

  1. Open the login page.
  2. Enter a registered email address.
  3. Enter the correct password.
  4. Click Login.
  5. Verify that the dashboard appears.

Difference

Test Scenario Test Case
Describes what to test Describes how to test
High-level Detailed
May cover several cases Targets a specific condition
Helps identify test coverage Helps execute and document checks

One scenario can have multiple test cases.

8. How to Write Test Cases

A good test case should be clear, repeatable, and easy for another tester to understand.

Common Test Case Fields

Test Case Template

Field Example
Test Case ID LOGIN-001
Title Login with valid credentials
Preconditions A registered active account exists
Test Data Valid email and password
Steps Open login page, enter credentials, click Login
Expected Result User reaches the dashboard
Actual Result Fill in after execution
Status Not Run
Priority High

Tips for Writing Good Test Cases

  1. Use simple, unambiguous language.
  2. Keep each case focused on a specific behavior.
  3. Include positive and negative conditions.
  4. State expected results clearly.
  5. Use realistic test data.
  6. Include boundary values where relevant.
  7. Avoid unnecessary duplication.
  8. Link test cases to requirements when possible.

9. Test Case Examples

Example 1: Login Page

ID Test Condition Expected Result
LOGIN-001 Valid email and password Login succeeds
LOGIN-002 Incorrect password Appropriate error appears
LOGIN-003 Unregistered email Login is rejected safely
LOGIN-004 Both fields empty Required-field validation appears
LOGIN-005 Invalid email format Validation message appears
LOGIN-006 Password field entered Characters are masked by default
LOGIN-007 Submit button clicked once Request is handled correctly
LOGIN-008 User logs out Protected pages require authentication

Exact messages and behavior should follow the product requirements.

Example 2: Registration Form

Test the following conditions:

Example 3: Shopping Cart

ID Test Condition Expected Result
CART-001 Add a product Product appears in the cart
CART-002 Increase quantity Quantity and total update correctly
CART-003 Remove a product Product is removed
CART-004 Add an unavailable product Appropriate restriction appears
CART-005 Apply a valid coupon Discount is calculated correctly
CART-006 Apply an invalid coupon Clear validation message appears
CART-007 Refresh the cart page Cart state behaves as specified

Example 4: Boundary Value Testing

Suppose an age field accepts values from 18 to 60 inclusive.

Useful boundary tests include:

Boundary Value Analysis focuses on values at and around the limits because errors often occur at boundaries.

10. Bug Reporting and Defect Life Cycle

A bug is a problem in software behavior that causes the application to behave differently from its requirements or expected behavior.

A useful bug report helps developers reproduce, understand, and investigate the issue.

Common Bug Report Fields

Sample Bug Report

Bug ID: LOGIN-BUG-001

Title: Login fails with valid credentials

Environment: Staging website, Chrome browser

Precondition: A registered and active test account exists.

Steps to Reproduce:

  1. Open the login page.
  2. Enter valid account credentials.
  3. Click Login.

Expected Result: The user should reach the dashboard.

Actual Result: The page displays an unexpected error and the user remains logged out.

Severity: Major, depending on scope and impact.

Priority: High, if login is a critical user journey.

Evidence: Attach a screenshot or relevant error details.

Note: Always use approved test accounts and avoid including real passwords, access tokens, or sensitive personal information in bug reports.

Defect Life Cycle

A common defect workflow is:

  1. New — The issue is reported.
  2. Assigned — The issue is assigned to an owner.
  3. In Progress — Investigation or fixing begins.
  4. Fixed — A fix is provided.
  5. Retest — QA verifies the fix.
  6. Closed — The issue is confirmed resolved.

Other possible statuses include Reopened, Rejected, Duplicate, Deferred, and Cannot Reproduce.

Actual workflows vary by organization and tracking tool.

11. Severity vs Priority

Severity describes the impact of a defect on the application. Priority describes how urgently the team should address it.

Severity Priority Example
High High Checkout is unavailable to all users
High Lower Serious issue in a rarely used legacy feature
Low High Typo in a critical launch announcement
Low Low Minor spacing issue on a low-traffic page

These combinations are illustrative, not universal rules. Teams should assess the actual impact, business needs, user reach, and release timing.

Severity Levels

Severity labels differ across teams.

12. Real-World Testing Example: Online Shopping Website

Imagine you are assigned to test an online shopping website.

Feature 1: User Login

Verify valid and invalid credentials, required fields, session handling, logout, and access to protected pages.

Feature 2: Product Search

Verify that:

Feature 3: Product Details

Check product name, price, images, availability, descriptions, and variant selection.

Feature 4: Shopping Cart

Verify adding, updating, and removing products. Check that totals, discounts, and quantities remain consistent.

Feature 5: Checkout

Check address validation, order summary, delivery options, and supported payment flows.

Use a sandbox payment environment or approved test payment method. Never test with unauthorized real payment details.

Feature 6: Order Confirmation

Verify that successful orders produce the expected confirmation and that the order details are accurate.

Example Test Execution Summary

Test Case Result
Login with valid credentials Pass
Search for an existing product Pass
Add product to cart Pass
Update product quantity Fail
Checkout using approved test payment Not Run

In this example, quantity updating needs investigation. The checkout test remains unexecuted and should not be counted as a pass.

13. Manual Testing Tools

Manual testing can be performed without specialized tools, but tools improve organization and evidence collection.

Test Management

Examples include TestRail, Zephyr, and other test management systems.

Use these to organize test cases, record execution results, and monitor coverage.

Bug Tracking

Examples include Jira, Linear, and GitHub Issues.

Use these to report defects, assign owners, and track progress.

Browser Developer Tools

Chrome DevTools and similar tools help inspect page elements, network requests, console errors, storage, and responsive layouts.

API Testing

Postman can help testers send API requests, inspect responses, and verify status codes and response data.

Documentation and Spreadsheets

Documents and spreadsheets can be useful for small projects, provided the team maintains clear ownership, versioning, and access controls.

Choose tools based on project needs rather than assuming every project requires all of them.

14. Manual Testing Best Practices

Understand the Business Requirements

Know what the feature should do and why it matters.

Prioritize Risky Features

Focus first on critical user journeys, frequently used features, security-sensitive areas, and recent changes.

Cover Positive and Negative Cases

Test valid inputs and expected failures.

Use Equivalence Partitioning

Divide input values into groups expected to behave similarly, then choose representative values from each group.

Apply Boundary Value Analysis

Test the limits of accepted values and nearby invalid values.

Keep Test Data Organized

Use controlled test accounts and reset data when needed.

Record Evidence

Capture relevant screenshots, logs, timestamps, and environment details.

Communicate Clearly

Report defects objectively, with reproducible steps and the observed impact.

Retest and Regress

Confirm fixes and check related functionality.

Keep Documentation Updated

Revise test cases when requirements or application behavior change.

15. Common Manual Testing Mistakes

Avoid these frequent mistakes:

  1. Testing only the happy path.
  2. Ignoring negative and boundary conditions.
  3. Writing vague test cases.
  4. Reporting bugs without reproduction steps.
  5. Confusing severity with priority.
  6. Skipping regression testing after changes.
  7. Using inconsistent test data.
  8. Failing to record the test environment.
  9. Marking unexecuted tests as passed.
  10. Testing production systems without authorization.
  11. Including sensitive information in screenshots or reports.
  12. Assuming that passing tests proves the software has no defects.

Testing reduces risk and provides evidence of quality; it cannot guarantee the complete absence of bugs.

16. Practical Exercises with Solutions

Try these exercises before reviewing the suggested answers.

Exercise 1: Login Testing

A login form contains email and password fields.

Write five test cases.

Suggested Solution:

  1. Valid email and password — Login succeeds.
  2. Valid email and incorrect password — Login is rejected with an appropriate message.
  3. Empty email and password — Required-field validation appears.
  4. Invalid email format — Validation appears according to requirements.
  5. Password entered — Characters are masked by default.

Additional tests could cover account lockout, session expiry, and rate limiting, depending on requirements.

Exercise 2: Age Validation

A form accepts ages from 18 to 60 inclusive.

Which values should you test?

Suggested Solution:

Test 17, 18, 19, 59, 60, and 61.

These values cover the boundaries and adjacent values.

Exercise 3: Write a Bug Report

A user clicks Add to Cart, but the cart count does not update.

Suggested Solution:

Title: Cart count does not update after adding a product

Steps:

  1. Open the product page.
  2. Select an available product.
  3. Click Add to Cart.
  4. Observe the cart count.

Expected Result: The cart count updates according to the product quantity.

Actual Result: The cart count remains unchanged.

Severity/Priority: Assess after checking whether the product was actually added and whether the issue affects other cart functions.

Evidence: Attach a screenshot or short recording.

Exercise 4: Registration Testing

List at least six test scenarios for a registration page.

Suggested Solution:

  1. Valid registration details.
  2. Empty required fields.
  3. Invalid email format.
  4. Weak password.
  5. Mismatched password confirmation.
  6. Duplicate registered email.
  7. Missing required consent.
  8. Successful verification flow.

Exercise 5: Shopping Cart Testing

A shopping cart allows users to change product quantity.

Suggested Solution:

Check quantity one, multiple units, minimum allowed quantity, maximum allowed quantity, invalid quantity input, removal of a product, and whether the total price updates correctly.

The exact expected behavior should follow the product requirements.

17. Manual Testing Interview Questions

Q1. What is manual testing?

Manual testing is the process of executing test cases by hand to verify application behavior against requirements.

Q2. What is a test case?

A test case is a documented set of preconditions, inputs, steps, and expected results used to verify a specific condition.

Q3. What is a test scenario?

A test scenario is a high-level description of a feature or behavior that needs testing.

Q4. What is the difference between retesting and regression testing?

Retesting verifies that a specific reported defect has been fixed. Regression testing checks whether changes have broken previously working functionality.

Q5. What is smoke testing?

Smoke testing is a quick check of critical functionality to decide whether a build is stable enough for further testing.

Q6. What is exploratory testing?

Exploratory testing involves learning about the application while designing and executing tests, often without relying exclusively on predefined test cases.

Q7. What is a defect life cycle?

It is the sequence of states a reported defect moves through, from initial reporting to resolution or closure.

Q8. Can manual testing be automated?

Manual test execution can be automated by converting suitable checks into scripts, but exploratory testing and human judgment remain valuable.

Q9. What is a test environment?

A test environment is the configured combination of application build, devices, browsers, services, data, and infrastructure used for testing.

Q10. When should manual testing be used?

It is especially useful for exploratory checks, usability evaluation, changing features, and situations where human observation is important.

18. Manual Testing Career Roadmap

Follow this learning path to build practical QA skills.

Stage 1: Learn the Fundamentals

Study software development basics, SDLC, STLC, testing principles, and common testing types.

Stage 2: Practice Test Case Design

Write test cases for login pages, registration forms, search, shopping carts, and checkout workflows.

Stage 3: Learn Bug Reporting

Practice creating clear defect reports with reproduction steps, expected results, actual results, and supporting evidence.

Stage 4: Explore Testing Techniques

Learn equivalence partitioning, boundary value analysis, decision tables, and state transition testing.

Stage 5: Use Common Tools

Practice with a bug tracker, browser developer tools, spreadsheets, and an API testing tool.

Stage 6: Build a Portfolio

Create a small testing project containing:

Use a demo application or a project you are authorized to test.

Stage 7: Learn Automation Basics

Once your manual testing fundamentals are strong, explore Selenium or Playwright, then learn a programming language and test framework.

Stage 8: Prepare for Interviews

Practice explaining your testing approach, how you prioritize work, how you report defects, and how you respond when requirements are unclear.

19. Frequently Asked Questions

Is manual testing easy to learn?

The fundamentals are accessible to beginners, but effective testing requires analytical thinking, careful observation, domain understanding, and practice.

Do I need coding knowledge for manual testing?

Not usually for basic manual testing. However, programming knowledge is helpful for automation, technical debugging, and API testing.

Is manual testing still useful?

Yes. Manual testing remains valuable for exploratory testing, usability, rapidly changing features, and checks that require human judgment.

Which tools should a beginner learn?

Start with browser developer tools, a bug-tracking tool, spreadsheets or test management software, and Postman for API basics.

How many test cases should a feature have?

There is no universal number. Coverage depends on complexity, risk, requirements, user journeys, and the potential impact of failure.

What is the difference between QA and testing?

Testing is an activity that evaluates software behavior. Quality assurance is broader and includes processes intended to prevent defects and improve quality throughout development.

Can manual testers become automation engineers?

Yes. Learning programming fundamentals, test design, version control, and automation frameworks can help manual testers transition into automation roles.

What should I include in my first QA portfolio?

Include a test plan, test scenarios, test cases, sample bug reports, evidence, and a concise test execution summary.

20. Final Checklist

Before completing a manual testing task, confirm that you have:

Continue learning with these Software Testing & QA guides:

  1. Software Testing: Complete Beginner to Advanced Guide
  2. Software Testing Life Cycle (STLC): Complete Guide
  3. How to Write Test Cases: Examples and Templates
  4. Bug Reporting and Defect Life Cycle
  5. Functional vs Non-Functional Testing
  6. Automation Testing: Complete Beginner Guide

Note: Update the related-guide URLs if your website uses a different route structure.


Conclusion: Manual testing is a foundational software quality skill. By learning test design, executing meaningful checks, documenting defects clearly, and practicing with real applications, you can develop the skills needed for QA projects and future automation testing.

More guides