What is manual?

Manual testing is a type of software testing where a real person checks an application’s functionality, usability, and performance without using any automated tools or scripts. The tester follows a set of test cases or explores the app freely, interacts with it just like an end‑user would, and records any defects they find.

Let's break it down

  • Plan: Define what features need testing and write test cases or checklists.
  • Set up: Prepare the test environment (install the app, configure devices, etc.).
  • Execute: Perform the steps in each test case, clicking buttons, entering data, and observing results.
  • Record: Note any unexpected behavior, screenshots, and steps to reproduce the issue.
  • Report: Share findings with developers through a bug tracking system.
  • Retest: After fixes, run the same steps again to confirm the problem is resolved.

Why does it matter?

Manual testing catches problems that automated scripts might miss, such as visual glitches, confusing workflows, or issues that only appear under real‑world usage. It provides a human perspective on the product’s quality, helps ensure a good user experience, and is essential for early‑stage development when the codebase changes rapidly.

Where is it used?

  • Early development phases before automation is set up.
  • User interface (UI) and user experience (UX) testing.
  • Exploratory testing where testers investigate without predefined steps.
  • Small projects or startups with limited resources.
  • Situations requiring ad‑hoc checks, like a quick sanity test after a minor bug fix.

Good things about it

  • Flexibility: Testers can adapt on the fly and explore unexpected areas.
  • Low initial cost: No need to write scripts or maintain testing frameworks.
  • Real‑user insight: Finds issues that affect actual users, such as confusing navigation.
  • Quick feedback: Immediate results without waiting for automated test runs.

Not-so-good things

  • Time‑consuming: Each test must be performed manually, which can slow down release cycles.
  • Human error: Mistakes or missed steps can lead to undetected bugs.
  • Not repeatable: Hard to run the exact same test consistently across builds.
  • Scalability limits: Difficult to cover large codebases or run tests on many devices simultaneously.