What belongs in the comment, attachment and actual-versus-expected fields of a recorded manual test result, and what makes that record useless a week later?
answer
- write for the reader who was not there
- the state will not exist tomorrow
- copy the expectation, do not recall it
- identity: build, environment, data
- evidence captured during the run
basics
~20 sRecord what was observed verbatim against the expectation copied from the step, the identity of the build, environment and data used, and evidence captured while the state still existed. Records fail later because that state is gone and cannot be reconstructed from memory.
solid answer
~50 sThe three fields have three different jobs. Actual-versus-expected is a comparison: the expected side is copied from the step's stated expectation, not written from memory, so a later reader can tell whether the product was wrong or the case was stale; the actual side is what was observed, quoted exactly, with the real values and messages rather than a paraphrase. The comment carries the context the comparison cannot: which build, which environment, which account or data set, and any deviation from the written steps. The attachment carries the bytes - a capture of the state, taken while it existed, because it will not exist tomorrow. What makes a record useless a week later is nothing to do with the outcome word: it is a comment that says it did not work, an expectation recalled rather than quoted, no build identity, and evidence promised but never attached.
go deeper
Know that a failed result needs what you saw, what the case said should happen, and a capture showing it. Never leave the comment as it did not work.
Explain why the expected side is copied from the step rather than recalled, and why evidence has to be captured during the run instead of reconstructed once the environment has been rebuilt.
Show the judgment about proportion: full evidence on failures, identity on passes, the obstacle on blocked. Be ready to describe how you handle evidence that cannot be stored, and how you spot records that will not survive the week.
Own the standard and its cost. Argue what the team is required to record on each outcome, why an unaffordable rule produces empty comments, and how the execution record stays useful independently of the defect it prompted.
A manual result is more than an outcome word. The fields around it are what make the outcome checkable by someone who was not there, on a day when the environment has been rebuilt and the tester has moved to another cycle. Getting them right is a recording discipline, and it is almost entirely about anticipating that reader. ## Three fields, three jobs | Field | Its job | The failure mode | |---|---|---| | Expected | Anchors the comparison to what the case actually claimed | Restated from memory, so nobody can tell if the case was stale | | Actual | Records the observation verbatim, values and messages included | Paraphrased into it looked wrong or it did not work | | Comment | Carries the run context the comparison cannot hold | Left empty, or used to retell the steps that are already written down | | Attachment | Carries the bytes of a state that will not exist tomorrow | Promised for later, captured too wide, or never taken at all | The expected side is the one people undervalue. Copying it from the step, rather than typing what you thought should happen, is what lets a later reader settle the question of whether the **product** deviated or the **case** was out of date. Those two look identical in a record that has only the actual side. ## What the record has to survive Write for the reader who arrives after the moment is gone. By then: - the environment has been redeployed, so the state that produced the result no longer exists - the build under test has been superseded, possibly several times - the test account has been reset, or the data seeded over - the tester has forgotten the details and may be on another team Everything that only lived in that moment must be in the record or it is lost. In practice that means **identity** - the build, the environment, the account or data set, the time - plus the observation itself and one piece of evidence that shows it. ## What good evidence looks like 1. **Captured during the run**, not reconstructed afterwards. Evidence gathered by trying to reproduce it later is a different observation, and if it does not reproduce you have nothing. 2. **Scoped to the moment.** A capture of the specific screen, message or response beats a capture of a whole desktop that a reader must hunt through. 3. **Attached where it is local** - at the failing step when the tool records results per step, so the reader lands on it instead of scanning the whole case. 4. **Readable without the tool that produced it.** Evidence that needs a session, a live environment or a tester's local machine to interpret is evidence only for as long as those exist. 5. **Safe to store.** If the observation involves real customer data, capture what proves the deviation and redact the rest, or reference an identifier that points at the state instead of copying it in. ## The failure modes that kill a record These are all cheap to commit and expensive to discover: - **It did not work.** The single commonest defect in manual records: an outcome word with no observation behind it. A week later there is no way to tell what was seen. - **See the ticket.** The execution record becomes a pointer to a defect report, so anyone reading the cycle has to leave it, and if the ticket is closed or merged the trail ends. - **Expected written from memory**, which makes a stale case indistinguishable from a real defect. - **No build or environment identity**, so nobody can tell whether the observation still applies to anything currently deployed. - **Evidence to follow**, which almost never follows, because the environment is gone by the time anyone chases it. - **A wall of narration** retelling steps that are already written in the case, burying the one sentence that mattered. ## Proportion by outcome Not every result needs the same weight, and demanding it of every pass is how a team learns to write nothing at all: - **A pass** usually needs only identity - build and environment - because the case text already says what was checked. The exception is a pass that overturns a previous failure, or a check expensive enough that nobody will want to repeat it. - **A failure** needs all three fields: the comparison, the context, and the evidence. - **A blocked result** needs the obstacle named specifically, with enough identity for someone to check whether it still stands. One useful border: the execution record is not the defect report. The record's job is to make the run reconstructible and the observation checkable, which is a different artefact with a different lifetime - the record stays attached to this cycle even after the ticket it prompted has been closed, merged or rejected.
- Does a passing manual result need the same evidence discipline as a failing one?No, and demanding it teaches people to write nothing. A pass usually needs only build and environment identity, because the case text already states what was checked. Two exceptions deserve evidence: a pass that overturns an earlier failure, and a check expensive or awkward enough that nobody will willingly repeat it to confirm the claim.
- What do you do when the evidence you need cannot be attached, for example because it contains real customer data?Capture only what proves the deviation and redact the rest, or record an identifier that points at the state in the system rather than copying the data into the record. Note the constraint in the comment so a later reader knows why the evidence is thin rather than assuming the tester was careless.
saying these in an interview costs you the question
- Recording a failure with the comment it did not work
- Writing the expected value from memory
- Pointing the record at a ticket instead of describing the observation
- Promising to attach evidence after the run
- Omitting the build and environment entirely
- Retelling the case steps in the comment