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
- What Is Manual Testing?
- Why Is Manual Testing Important?
- Manual Testing vs Automation Testing
- How Manual Testing Works
- Software Testing Life Cycle
- Types of Manual Testing
- Test Scenario vs Test Case
- How to Write Test Cases
- Test Case Examples
- Bug Reporting and Defect Life Cycle
- Severity vs Priority
- Real-World Testing Example
- Manual Testing Tools
- Manual Testing Best Practices
- Common Mistakes to Avoid
- Practical Exercises with Solutions
- Manual Testing Interview Questions
- Career Roadmap
- 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:
- Enter a valid username and password.
- Click the Login button.
- Verify that the user reaches the dashboard.
- Enter an incorrect password.
- Check whether an appropriate error message appears.
- Leave required fields empty and observe the result.
If the application behaves differently from the expected result, the tester investigates and reports the issue.
Key Characteristics
- Testers execute checks manually.
- Test cases are based on requirements and expected behavior.
- Testers can explore unexpected user interactions.
- Results are compared with expected outcomes.
- Bugs are documented for developers to investigate.
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:
- Repeated checks can consume significant time.
- Results may vary between testers.
- Large regression suites can be expensive to execute manually.
- Human error can cause steps to be missed.
- It is less suitable for repeatedly testing thousands of data combinations.
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:
- Login with valid credentials.
- Login with an incorrect password.
- Login with an unregistered email.
- Submit the form with empty fields.
- Check password masking.
- Verify the logout process.
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:
- Open the login page.
- Enter a registered email address.
- Enter the correct password.
- Click Login.
- 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 ID: Unique identifier.
- Title: Short description.
- Preconditions: What must be true before testing.
- Test Data: Inputs required.
- Steps: Actions to perform.
- Expected Result: Correct behavior.
- Actual Result: Observed behavior.
- Status: Pass, Fail, Blocked, or Not Run.
- Priority: Importance of executing the case.
- Comments/Evidence: Supporting details or screenshots.
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
- Use simple, unambiguous language.
- Keep each case focused on a specific behavior.
- Include positive and negative conditions.
- State expected results clearly.
- Use realistic test data.
- Include boundary values where relevant.
- Avoid unnecessary duplication.
- 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:
- All required fields contain valid data.
- Required fields are left empty.
- Email format is invalid.
- Password does not meet complexity rules.
- Password confirmation does not match.
- An account already exists for the email.
- Terms and conditions are not accepted when acceptance is required.
- Successful registration displays the expected confirmation.
- Verification email behavior matches requirements.
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:
- 17: Should be rejected.
- 18: Should be accepted.
- 19: Should be accepted.
- 59: Should be accepted.
- 60: Should be accepted.
- 61: Should be rejected.
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
- Bug ID
- Bug title
- Environment and application version
- Preconditions
- Steps to reproduce
- Expected result
- Actual result
- Severity and priority
- Screenshots, logs, or video evidence
- Current status
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:
- Open the login page.
- Enter valid account credentials.
- 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:
- New — The issue is reported.
- Assigned — The issue is assigned to an owner.
- In Progress — Investigation or fixing begins.
- Fixed — A fix is provided.
- Retest — QA verifies the fix.
- 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
- Critical: A major service or essential business function is unavailable.
- Major: Important functionality is seriously affected.
- Minor: A limited problem with a workaround.
- Trivial: Small cosmetic or wording issue.
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:
- Relevant products appear for valid searches.
- No-result searches display a helpful message.
- Search handles leading and trailing spaces appropriately.
- Search is usable on supported devices.
- Filters and sorting work correctly.
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:
- Testing only the happy path.
- Ignoring negative and boundary conditions.
- Writing vague test cases.
- Reporting bugs without reproduction steps.
- Confusing severity with priority.
- Skipping regression testing after changes.
- Using inconsistent test data.
- Failing to record the test environment.
- Marking unexecuted tests as passed.
- Testing production systems without authorization.
- Including sensitive information in screenshots or reports.
- 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:
- Valid email and password — Login succeeds.
- Valid email and incorrect password — Login is rejected with an appropriate message.
- Empty email and password — Required-field validation appears.
- Invalid email format — Validation appears according to requirements.
- 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:
- Open the product page.
- Select an available product.
- Click Add to Cart.
- 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:
- Valid registration details.
- Empty required fields.
- Invalid email format.
- Weak password.
- Mismatched password confirmation.
- Duplicate registered email.
- Missing required consent.
- 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:
- A test plan.
- A test scenario list.
- At least 20 well-written test cases.
- Sample defect reports.
- A test execution summary.
- A short final test report.
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:
- Understood the requirements.
- Identified important test scenarios.
- Covered positive and negative cases.
- Checked relevant boundary conditions.
- Prepared suitable test data.
- Executed the planned test cases.
- Recorded actual results accurately.
- Reported defects with clear reproduction steps.
- Retested fixes.
- Considered regression risks.
- Protected sensitive information.
- Summarized results and unresolved risks.
Related Guides on Codify
Continue learning with these Software Testing & QA guides:
- Software Testing: Complete Beginner to Advanced Guide
- Software Testing Life Cycle (STLC): Complete Guide
- How to Write Test Cases: Examples and Templates
- Bug Reporting and Defect Life Cycle
- Functional vs Non-Functional Testing
- 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
- How to Use Codify: A 7-Day Start Plan — New here? Pick a roadmap, make a study plan, start the DSA sheet, revise with notes, practise for placements and test yourself — one step a day, then a daily routine.
- Infosys Preparation Guide: Online Test, Pseudocode and Interview — Roles (SE, DSE, SP), what each section of the Infosys online test checks, how to crack pseudocode and reasoning, a 4-week plan and the interview.
- Wipro Elite NLTH Preparation: Aptitude, Essay and Coding — The Wipro fresher test round by round — quant, logical and verbal, the written essay, two coding problems — plus a 3-week plan and interview tips.
- Accenture Preparation Guide: Cognitive, Technical, Coding and Communication — Every Accenture round explained — cognitive, MS Office/networking/cloud technical MCQs, pseudocode, coding and the spoken-English test — with a 4-week plan.