Exit course
Chapter 3 of 9 Beginner 6 min read 2 quick checks Updated

Writing Test Cases and Checklists That Stay Useful

On this page
  1. Test case or checklist?
  2. Anatomy of a test case that survives
  3. Checklists: short, ordered, owned
  4. 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?#

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#

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?

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#

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#

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?

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.