---
title: Writing Test Cases and Checklists That Stay Useful
description: Test design gives you a list of things worth trying. This chapter is
  about writing them down in a form someone else can run next month, after the product
  has…
source_url:
  html: https://testingbot.com/resources/courses/manual-testing/test-cases-and-checklists
  md: https://testingbot.com/resources/courses/manual-testing/test-cases-and-checklists.md
---

Course

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

Chapter 3 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 3 of 9 Beginner 6 min read 2 quick checks Updated Nov 2026 

# Writing Test Cases and Checklists That Stay Useful
On this page
1. [Test case or checklist?](https://testingbot.com#test-case-or-checklist)
2. [Anatomy of a test case that survives](https://testingbot.com#anatomy-of-a-test-case-that-survives)
3. [Checklists: short, ordered, owned](https://testingbot.com#checklists-short-ordered-owned)
4. [Where to keep them](https://testingbot.com#where-to-keep-them)

Test design gives you a list of things worth trying. This chapter is about writing them down in a form someone else can run next month, after the product has changed twice. Most written tests fail at that: they are either so detailed that every UI change breaks them, or so vague that two testers run them differently.

## Test case or checklist?[#](https://testingbot.com#test-case-or-checklist)

Two formats cover nearly every need:

- **A test case** is a precise, repeatable check: preconditions, steps, expected result. Use it when the exact steps matter: acceptance criteria someone signs off, a regulated flow, a tricky reproduction, or a check you are about to hand over for automation.
- **A checklist** is a list of things to verify, without prescribing every click. Use it for regression passes, release checks and cross-browser sweeps, where the tester knows the product and the value is in not forgetting anything.

A team that writes everything as detailed test cases spends its time maintaining documents. A team with only checklists cannot hand work to new people. Most mature teams keep a small set of test cases for the critical flows and checklists for everything else.

## Anatomy of a test case that survives[#](https://testingbot.com#anatomy-of-a-test-case-that-survives)

Here is a test case for the shipping rule from the previous chapter:

> **ID:** CHK-014 **Title:** Order of exactly 50.00 ships free **Requirement:** Shipping rule (orders of 50.00 or more ship free) **Preconditions:** Logged-in customer with a UK delivery address; no coupon; cart empty. **Data:** Product "Desk lamp" priced 50.00.
> 
> **Steps:**
> 
> 1. Add one "Desk lamp" to the cart.
> 2. Go to checkout and choose standard delivery.
> 
> **Expected:** Subtotal 50.00, shipping 0.00, total 50.00. The order summary says "Free shipping".

What makes it last:

- **The title states the behaviour,** not the action. "Order of exactly 50.00 ships free" tells you what broke when it fails; "Checkout test 3" tells you nothing.
- **Preconditions and data are explicit.** Most "cannot reproduce" arguments come from a hidden precondition: a coupon left in the cart, a different country, a user who already had an order.
- **Steps describe intent, not pixels.**"Go to checkout" instead of "Click the orange button in the top right corner". The button will move; the intent will not.
- **One expected result per behaviour, stated precisely.**"Shipping is 0.00" can be checked. "The page displays correctly" cannot.
- **It traces to a requirement,** so that when the rule changes, you can find every test that needs updating.

Avoid the common anti-patterns: a 40-step case that tests six things (when step 12 fails, the other 28 steps go unrun), expected results that only say "works", and steps that depend on data another test case created.

Which expected result is the most useful in a test case for a password reset email?

 The password reset works correctly. Click the blue "Reset" link in the email and check the page. An email arrives within 2 minutes; its link opens the "Choose a new password" page; the link stops working after one use.

A useful expected result is observable and specific, so two testers reach the same verdict. "Works correctly" leaves the verdict to whoever runs it, and the second option is a step with a colour in it, not an expected result.

## Checklists: short, ordered, owned[#](https://testingbot.com#checklists-short-ordered-owned)

A good checklist reads like a pilot's: short enough to actually be used, ordered the way you move through the product, and specific enough that each line has a clear yes or no.

A release checklist for a shop's checkout might start like this:

- Cart: add, change quantity, remove; totals update without a reload.
- Shipping: 49.99 charges 4.95; 50.00 is free.
- Coupon: valid code applies once; expired code shows the expiry message; code cannot be applied twice.
- Address: postcode with and without a space; a long street name does not break the layout.
- Payment: test card succeeds; declined card shows a message and keeps the cart.
- Confirmation: email arrives; order appears in "My orders" with the right status.
- Back after paying does not create a second order.

Each line packs several checks that an experienced tester will run without being told how. That is the trade-off: a checklist relies on the tester's product knowledge, so pair new people with someone the first time through.

Keep checklists alive:

- **Give each one an owner** who updates it when the feature changes.
- **Add a line for every escaped bug.** If a bug reached production because nobody checked something, that something goes on the list. Over time the checklist becomes a record of how this product actually breaks.
- **Remove lines that are now automated** and reliably green. A checklist that grows forever stops being used.
- **Keep it under a page.** If it is longer, split it by area.

## Where to keep them[#](https://testingbot.com#where-to-keep-them)

A spreadsheet, a page in your wiki, or a test management tool all work. What matters is that tests live next to the requirements they cover, that you can see when each was last run and by whom, and that results (passed, failed, blocked, not run) are recorded per release. A test case nobody can find is a test case nobody runs.

A bug reached production: applying the same coupon in two browser tabs gave a double discount. What is the most useful change to your process?

 Rewrite the whole coupon checklist as detailed step-by-step test cases Add "same coupon in two tabs applies only once" to the coupon checklist and consider it for automation Nothing: two-tab cases are too rare to test

An escaped bug is evidence of a gap. One precise line closes it for every future release, and because it is a clear yes-or-no check it is also a good automation candidate. Rewriting everything as detailed cases adds maintenance without addressing the gap, and the bug already proved the case is not too rare.

[Previous · Chapter 2 Test Design: Partitions, Boundaries and States](https://testingbot.com/resources/courses/manual-testing/test-design-techniques) [Next · Chapter 4 Exploratory Testing with Charters and Session Notes](https://testingbot.com/resources/courses/manual-testing/exploratory-testing)

On this page

1. [Test case or checklist?](https://testingbot.com#test-case-or-checklist)
2. [Anatomy of a test case that survives](https://testingbot.com#anatomy-of-a-test-case-that-survives)
3. [Checklists: short, ordered, owned](https://testingbot.com#checklists-short-ordered-owned)
4. [Where to keep them](https://testingbot.com#where-to-keep-them)
