Manual Testing: Definition, Test Types and Process in Practice
Everyone is talking about test automation, and yet in most software projects a large share of tests is still carried out by people. There are good reasons for this: some defects are only found by someone who uses the software the way real users will. This article explains what manual testing is, which test types it covers, how a manual software test works and when it beats automation.
What is manual testing? Definition
Manual testing means that a tester operates the software personally instead of having a script run the test steps. The tester clicks through screens, enters data, checks results and compares the actual behaviour with the expected behaviour. The basis is requirements, user stories, acceptance criteria or the tester's experience with similar systems.
Manual does not mean unplanned. A professional manual test has a goal, a defined test basis, traceable test cases or a test charter, and documented results. Tools are still used, for example to manage test cases, record defects or take screenshots. What matters is that a person carries out and evaluates the test.
Which tests are performed manually?
Almost every test type and test level can be performed manually. In practice, these are the most common:
- Functional tests: Checking whether a function meets the requirement, for example whether an order is created and confirmed correctly.
- Exploratory tests: The tester explores the application in a targeted way, often in time-boxed test sessions with a test charter instead of fixed steps. This reveals defects nobody thought of when writing the test cases. How such a session works is shown in our article on exploratory testing.
- End-to-end tests: A business process is run through across several systems, for example from the enquiry to the invoice to the incoming payment.
- User interface and usability tests: Are screens easy to understand, error messages helpful and workflows equally usable on smartphone and desktop?
- Acceptance tests: Before release, business users or the client checks whether the software is fit for use. More on this in the article on acceptance testing.
- Manual regression tests: After changes, existing functions are checked to make sure they still work. This makes sense as long as changes are rare or automation does not pay off yet, see regression testing.
- Smoke tests: A short check after each deployment to confirm that the most important functions basically work and further testing makes sense.
When does manual testing make sense?
Manual tests play to their strengths wherever human judgement is needed or automation does not pay off economically:
- New features: As long as the interface and behaviour still change often, automated tests would need constant adjustment.
- Usability: No script can judge whether a workflow is easy to understand.
- Rare or one-off checks: Data migrations, go-live checks or tests for a short-lived project.
- Complex business logic: When results can only be assessed with domain knowledge, for example in insurance or billing systems.
- Limited testability: Older systems without stable interfaces or unique element IDs are often very costly to automate.
Manual and automated testing compared
The question is rarely either/or, but which approach suits which purpose. Automated tests are strong at repetition: they run fast, overnight and with every build, always with the same steps. Manual tests are strong at the new and unexpected: a person notices that a button works but sits in the wrong place, or that a message leaves the user puzzled.
- Effort: Manual tests are quick to start but cost time again with every repetition. Automation needs an initial investment and maintenance, but pays off with frequent repetition.
- Flexibility: A tester adapts to changes on the spot, while a script often fails because a button has moved.
- Defect detection: Automated tests mainly check what was defined in advance. Manual tests, especially exploratory ones, also uncover new ones.
A proven pattern: stable, frequently repeated checks are automated step by step, while new features and critical workflows are also tested manually. How to get started with automation is described in the article Introducing test automation.
How a manual software test works in six steps
1. Clarify the test basis
Which requirements, user stories or process descriptions apply? Unclear or contradictory requirements already surface here and should be resolved before testing.
2. Define scope and priorities
Not everything can be tested equally thoroughly. Prioritised by risk, the areas where a defect would cause the most damage are tested first. The approach is shown in the article on risk-based testing.
3. Prepare test cases or test charters
Recurring checks are best covered by test cases with preconditions, steps and expected results. For exploratory sessions, a charter with goal, area and time frame is enough. How good test cases are structured is explained in How to write test cases.
4. Provide the test environment and test data
Manual tests are only as meaningful as the environment they run in. You need a stable test environment and suitable test data, such as customer accounts in different states.
5. Run tests and report defects
Every deviation is described so that developers can reproduce it: environment, steps, expected and actual result, screenshot and severity. A good defect report avoids follow-up questions and shortens the fix.
6. Retest, regression and test report
Fixed defects are verified by confirmation testing (retest), and related functions are covered by regression testing. The test report summarises what was tested, which defects remain open and whether release is recommended from a testing perspective.
Common mistakes in manual testing
- Testing without a goal: Simply clicking around finds random defects but gives no reliable statement about quality.
- Not documenting results: Without a record, nobody knows at the next release what has already been checked.
- Always taking the same paths: Repeated tests become routine and then miss exactly the new defects. Exploratory sessions bring a fresh view.
- Developers only test their own code: An independent view finds misunderstandings in the requirements that the developer cannot see.
- Starting too late: Manual tests just before go-live leave no time to fix the defects found properly.
Manual testing in-house or external?
Many companies have no dedicated test team. Developers test on the side, and business users check shortly before release. This often leads to gaps, because nobody has testing as their main job. An alternative is an external testing service provider that takes over test planning, manual tests and defect management and works closely with the project team. As a software testing service provider in Hamburg, we take over test planning and carry out manual software tests remotely, hybrid or on site, in Hamburg and across Germany.
Conclusion
Manual testing is not a thing of the past but an essential complement to automation. It is essential for new features, usability, complex business logic and anything that needs a human eye. With a clear test basis, risk-based priorities, clean documentation and well-described defects, manual tests provide a reliable basis for releasing your software.
Frequently asked questions about manual testing
What is the difference between manual and automated testing?
In manual testing, a person carries out the test steps and evaluates the result. In automated testing, a script runs the steps and compares results with defined expectations. Automation pays off for frequently repeated, stable checks, while manual tests suit new features, usability and exploratory defect finding.
Can test automation completely replace manual testing?
No. Automation can take over many recurring checks, but it only verifies what was defined in advance. Whether an interface is understandable or an unexpected sequence causes errors can usually only be judged reliably by a person. Most projects do best with a combination of both.
What does a manual tester do?
A manual tester analyses requirements, prepares test cases and test data, runs tests, documents deviations as defect reports and retests fixed defects. This also includes raising unclear requirements early and reporting the test status to the project team in an understandable way.
Manual software testing for your project
We take over the manual testing of your software, from test planning and execution to a test report with a release recommendation.
Book an initial consultationMore about our service: Software testing & quality assurance in Hamburg →