Manual Testing
Designing test cases, doing exploratory testing, writing test plans/checklists, or manually verifying a feature before or instead of automating it. Covers test case design techniques, exploratory charters, and test plan structure.
When to reach for this
- Before automation exists, or when automation isn't worth the cost (one-off, highly visual, exploratory).
- New feature needs a test plan.
- Investigating a reported bug and need a repeatable, structured approach.
Test case design techniques
Pick techniques based on the input space, don't just guess values:
- Equivalence partitioning — split inputs into classes that should behave the same; test one representative per class.
- Boundary value analysis — test min, min-1, min+1, max, max-1, max+1, and just-outside-range values. Most bugs live at boundaries.
- Decision table testing — for features with multiple independent conditions (e.g. role × subscription tier × feature flag), build a table of condition combinations and expected outcomes.
- State transition testing — for anything with a lifecycle (order status, account state), test valid transitions, invalid transitions, and transitions from every state.
- Pairwise/combinatorial testing — when full combinatorial coverage is too large, use pairwise coverage to catch most interaction bugs cheaply.
- Error guessing — based on experience: empty strings, nulls, huge inputs, unicode/emoji, SQL-special chars, double-submits, back-button, concurrent edits.
Exploratory testing (session-based)
- Charter — one sentence: what area, what risk you're hunting for. e.g. "Explore checkout discount code entry for validation and edge-case bugs, 30 min."
- Time-box — 30–90 min sessions. Don't sprawl.
- Tour styles to vary coverage:
- Landmark tour — visit every major screen/feature once.
- FedEx tour — follow one piece of data end-to-end through the system.
- Saboteur tour — try to break things: kill network mid-action, resize window, spam-click, go back/forward.
- Money tour — focus on whatever the business cares about most (checkout, signup, payment).
- Log as you go: what you did, what you noticed, questions raised, bugs found — even things that "seem fine but weird."
- Debrief: summarize coverage, bugs, and follow-up charters needed.
Test plan structure
# Test Plan: <Feature/Release>
## Scope
- In scope / out of scope
## Test approach
- Manual / automated split, environments, browsers/devices
## Entry criteria
- Feature deployed to staging, test data seeded, etc.
## Test cases
- ID | Title | Preconditions | Steps | Expected | Priority
## Risk areas
- What's most likely to break, and why
## Exit criteria
- % pass rate, zero blockers/criticals, sign-off owner
Checklist habits that catch real bugs
- Test with a freshly created account and an old account with legacy data — schema drift bugs hide here.
- Test empty states (zero items, zero results) not just populated ones.
- Test permissions boundaries: logged out, wrong role, expired session, another tenant's data.
- Test concurrency: two tabs, two users editing the same record, double-submit on slow network.
- Test input extremes: very long strings, unicode/emoji/RTL text, negative numbers, decimals where integers expected, huge file uploads.
- Test browser back/forward and refresh mid-flow.
- Always verify against the actual backend state (DB row, API response), not just what the UI shows — the UI can lie.
Reporting
When a manual test finds a defect, use the bug-reporting skill's template so severity/repro/evidence are consistent across every testing skill.