---
title: 'Manual Testing Course: Free Online Course | TestingBot'
description: 'A hands-on manual testing course: test design, test cases, exploratory
  charters, bug reports developers act on, cross-browser and real-device checks, mobile
  specifics and choosing what to automate.'
source_url:
  html: https://testingbot.com/resources/courses/manual-testing
  md: https://testingbot.com/resources/courses/manual-testing.md
---

Course

[Manual Testing Course](https://testingbot.com/resources/courses/manual-testing)

Chapter 1 of 9

1. [1 Manual Testing Course: What It Is For Today](https://testingbot.com/resources/courses/manual-testing)
2. [2 Test Design: Partitions, Boundaries and States](https://testingbot.com/resources/courses/manual-testing/test-design-techniques)
3. [3 Writing Test Cases and Checklists That Stay Useful](https://testingbot.com/resources/courses/manual-testing/test-cases-and-checklists)
4. [4 Exploratory Testing with Charters and Session Notes](https://testingbot.com/resources/courses/manual-testing/exploratory-testing)
5. [5 Writing Bug Reports Developers Act On](https://testingbot.com/resources/courses/manual-testing/bug-reports)
6. [6 Cross-Browser and Real-Device Testing with TestingBot Live](https://testingbot.com/resources/courses/manual-testing/cross-browser-testing-with-testingbot-live)
7. [7 Mobile Manual Testing: Gestures, Rotation, Interruptions](https://testingbot.com/resources/courses/manual-testing/mobile-manual-testing)
8. [8 Deciding What to Automate Next](https://testingbot.com/resources/courses/manual-testing/what-to-automate-next)
9. [9 Knowledge check](https://testingbot.com/resources/courses/manual-testing/knowledge-check)

[Exit course](https://testingbot.com/resources/courses)

 Chapter 1 of 9 Beginner 6 min read 1 quick check Updated Nov 2026 

# Manual Testing Course: What It Is For Today

A hands-on manual testing course: test design, test cases, exploratory charters, bug reports developers act on, cross-browser and real-device checks, mobile specifics and choosing what to automate.

## What you will learn

1. Manual Testing Course: What It Is For Today
2. [Test Design: Partitions, Boundaries and States](https://testingbot.com/resources/courses/manual-testing/test-design-techniques)
3. [Writing Test Cases and Checklists That Stay Useful](https://testingbot.com/resources/courses/manual-testing/test-cases-and-checklists)
4. [Exploratory Testing with Charters and Session Notes](https://testingbot.com/resources/courses/manual-testing/exploratory-testing)
5. [Writing Bug Reports Developers Act On](https://testingbot.com/resources/courses/manual-testing/bug-reports)
6. [Cross-Browser and Real-Device Testing with TestingBot Live](https://testingbot.com/resources/courses/manual-testing/cross-browser-testing-with-testingbot-live)
7. [Mobile Manual Testing: Gestures, Rotation, Interruptions](https://testingbot.com/resources/courses/manual-testing/mobile-manual-testing)
8. [Deciding What to Automate Next](https://testingbot.com/resources/courses/manual-testing/what-to-automate-next)
9. [Knowledge check](https://testingbot.com/resources/courses/manual-testing/knowledge-check)

[Continue where you left off](https://testingbot.com#)
On this page
1. [Manual testing in a team that automates](https://testingbot.com#manual-testing-in-a-team-that-automates)
2. [Scripted, exploratory and everything in between](https://testingbot.com#scripted-exploratory-and-everything-in-between)
3. [Usability, accessibility and "it feels wrong"](https://testingbot.com#usability-accessibility-and-it-feels-wrong)
4. [What you will be able to do](https://testingbot.com#what-you-will-be-able-to-do)
5. [Prerequisites](https://testingbot.com#prerequisites)

_Last reviewed November 2026._

Manual testing is a person using the software with intent: deciding what to try, watching what happens, and judging whether it is right. No script does the deciding. That makes it slow and impossible to repeat on every commit, and it also makes it the only kind of testing that notices things nobody wrote down.

This course is for testers who do that work, and for developers, designers and product people who do it part-time before a release. It is hands-on: every chapter ends in something you can use on your next ticket, whether that is a set of boundary values, a checklist, an exploratory charter or a bug report template. There is no code in it.

## Manual testing in a team that automates[#](https://testingbot.com#manual-testing-in-a-team-that-automates)

Most teams that ship web and mobile software run automated tests on every change. That does not make manual testing obsolete; it changes what it is for. Automated tests answer one question very well: "does the thing that worked yesterday still work?" They check exactly what someone told them to check and nothing else.

A manual tester answers different questions:

- **Does the new feature do what the ticket meant?** A feature in its first week has no automated tests worth the name, and the ones that exist were written by the same person who wrote the code, with the same assumptions.
- **Is it usable?** An automated test will happily click a button that is grey on grey, labelled "Submit" on a page with three "Submit" buttons, and pass.
- **What happens off the happy path?** Pasting a name with an apostrophe, pressing Back after paying, opening the same order in two tabs, losing the network halfway through an upload.
- **Does it work where users are?** On the browser, screen size and phone your users actually have, not the one on the developer's desk.
- **Is this customer's bug real, and how do we reproduce it?** Someone has to turn "it doesn't work on my iPhone" into steps a developer can follow.

Think of it as a division of labour. Automation guards what you already know. Manual testing finds out what you do not know yet, and some of what it finds becomes the next automated test (chapter 7 covers how to choose).

Your team's checkout has a solid automated end-to-end suite that passes on every commit. A new "split payment" option ships next week. Where does manual testing add the most value?

 Re-running the existing checkout steps by hand before each release, to double-check the suite Exploring the new split-payment option: odd amounts, cancelling halfway, Back and refresh, small screens None: a passing suite means the checkout works

The suite already checks the existing flow on every commit; repeating it by hand finds little. The new option has no tests yet and its behaviour off the happy path is unknown, which is exactly where a person's judgement finds bugs. A passing suite only proves what it checks.

## Scripted, exploratory and everything in between[#](https://testingbot.com#scripted-exploratory-and-everything-in-between)

Manual testing comes in two broad styles, and you will use both:

- **Scripted testing** follows written steps with expected results. It is repeatable and easy to hand to someone new, which suits regulated work, acceptance sign-off and regression checks that are not automated yet. Its weakness: the person stops looking once the steps are done.
- **Exploratory testing** designs and runs tests at the same time, guided by a goal (a _charter_) and what the software does as you go. It finds more bugs per hour on new or changed features. Its weakness: without structure it turns into aimless clicking that nobody can review.

Good testers mix them. A short checklist makes sure the important things are covered; time-boxed exploration finds what the checklist missed. Chapters 2 and 3 show how to keep each one disciplined.

## Usability, accessibility and "it feels wrong"[#](https://testingbot.com#usability-accessibility-and-it-feels-wrong)

Some of the most valuable manual findings are not functional failures at all: an error message that blames the user, a form that clears itself after a validation error, a focus order that jumps around for keyboard users, a confirmation step that appears only on some paths. They rarely fail an automated assertion, and they are precisely what users complain about.

When you find one, report it like any bug (chapter 4), with a concrete observation rather than an opinion. "The error 'Invalid input' appears under the postcode field when the postcode is valid but has a space at the end" is actionable. "The form is confusing" is not.

## What you will be able to do[#](https://testingbot.com#what-you-will-be-able-to-do)

By the end of this course you will be able to:

1. Derive a small, sharp set of test inputs from a requirement using equivalence partitions, boundary values and state transitions.
2. Write test cases and checklists that the next person can run, and that stay useful as the product changes.
3. Plan and run an exploratory session with a charter, and leave notes someone else can review.
4. Write bug reports that developers can reproduce on the first try.
5. Decide which browsers and devices to check, and run those checks on remote browsers and real phones with TestingBot Live, including a site on `localhost`.
6. Test mobile-specific behaviour: gestures, rotation, interruptions and permissions.
7. Pick what to automate next and hand it over to whoever writes the automation.

## Prerequisites[#](https://testingbot.com#prerequisites)

None beyond curiosity and access to some software to test. For the cross-browser and mobile chapters, a free TestingBot trial account lets you follow along on remote browsers and devices; the techniques work just as well on the hardware you have.

There is no certification for this course. TestingBot certificates require a practical task verified from automated test sessions on the grid, and manual testing skill cannot be verified honestly that way. The final chapter is a self-check knowledge test instead. When you move on to automation, the [Playwright](https://testingbot.com/resources/courses/playwright) and [Selenium with Java and TestNG](https://testingbot.com/resources/courses/selenium-testng) courses each end in a certification.

[Next · Chapter 2 Test Design: Partitions, Boundaries and States](https://testingbot.com/resources/courses/manual-testing/test-design-techniques)

On this page

1. [Manual testing in a team that automates](https://testingbot.com#manual-testing-in-a-team-that-automates)
2. [Scripted, exploratory and everything in between](https://testingbot.com#scripted-exploratory-and-everything-in-between)
3. [Usability, accessibility and "it feels wrong"](https://testingbot.com#usability-accessibility-and-it-feels-wrong)
4. [What you will be able to do](https://testingbot.com#what-you-will-be-able-to-do)
5. [Prerequisites](https://testingbot.com#prerequisites)

## Other free courses

- [Selenium Locators and Locator Strategies A free course on Selenium locators and locator strategies: CSS selectors, XPath, role-based and test-id loc...](https://testingbot.com/resources/courses/locator-strategies)
- [Accessibility Testing Tutorial: WCAG 2.2 A free, hands-on accessibility testing course: WCAG 2.2 in practice, manual keyboard and screen reader chec...](https://testingbot.com/resources/courses/accessibility-testing)
- [Mobile App Testing: From First Test to CI A free, hands-on mobile app testing course: emulators vs real devices, Appium vs Espresso vs XCUITest vs Ma...](https://testingbot.com/resources/courses/mobile-app-testing)
- [Flaky Tests: Find, Fix and Prevent Fix flaky tests for good: measure them, then remove the four root causes (waits, shared data, test order, r...](https://testingbot.com/resources/courses/flaky-tests)

[Browse all courses](https://testingbot.com/resources/courses)
