Skip to content
Kaarne Superstore⌕
AI & Digital Tools

Reproduce the Website Issue Before Changing the Code

Compare the reported website journey with your own attempt before editing code. Use a reproduction worksheet and a clear request for missing details.

An investigator follows a paper route toward a snag highlighted under an oversized magnifying glass.

The client can trigger the problem, but your first attempt looks normal. Changing the code immediately would mean choosing a cause before you have established the conditions. Start by making the difference between the two attempts visible.

Preserve the report as an observation

In this fictional example, a client says the service chooser loses its selected option when they return from another page. The implementer opens the chooser directly and sees a selection remain. Neither observation cancels the other: the starting route is already different.

Record the client’s reported sequence separately from your attempted sequence. Mark unknown details rather than silently completing them from experience. Mozilla’s bug-writing guidelines emphasise reproduction steps, expected and actual results, and separating observations from speculation. Use that discipline without requiring a client to become a browser-project bug reporter.

Make a small reproduction worksheet

Use these fields for each attempt:

  • Environment and version: the site or review environment and the version or time being examined.
  • Starting state: signed-in state if relevant, initial page and visible selection.
  • Route: the ordered actions, including how the person returns to the chooser.
  • Expected state: what the agreed behaviour would show at the end.
  • Observed state: what appeared, with the time and useful evidence.
  • Changed condition: what differs from the previous attempt, and why you varied it.
  • Remaining uncertainty: what has not been checked or cannot yet be established.

This worksheet continues a useful issue report into an investigation. Its purpose is to compare attempts, not repeat the initial report in increasingly technical language. Use harmless test content and an authorised environment for any action that could submit data or change records.

Compare the paths before varying everything else

For the fictional chooser, write the two paths plainly. Attempt A opens the chooser directly, makes a selection and remains on the page. The reported path opens the chooser, makes a selection, visits the service detail page, then returns. The return action is not yet known: the client might use a page link or the browser’s Back control.

Request that missing distinction first. Keep the entry, browser and other known conditions stable where practical while trying the described route. If you change several things at once, a different result will be harder to interpret. This is a proposed investigation sequence, not a test result from an actual chooser.

Ask without implying fault

“Thanks for describing the selection disappearing. My attempt so far started directly on the chooser and did not include the return journey. Could you tell me how you came back from the service page—using a link on the page or the browser’s Back control? I will compare that route with the direct-entry attempt. Please leave customer details out of any screenshot.”

The request explains why the question matters. It also makes your current evidence modest: one different attempt has not reproduced the issue. Avoid “it works for me” as a conclusion or an instruction to repeat the same steps without clarifying what differs.

Classify the outcome before choosing the fix

If you reproduce the reported state, record the exact route and use it to investigate the relevant implementation. If the result varies between attempts, preserve those differences and look for a condition worth isolating. If you still cannot reproduce it, keep the report open to further evidence and state the limits of the attempts made.

You may also discover an unsettled requirement: should the chooser remember a selection after that route? Establish the intended behaviour with the appropriate owner rather than treating whichever output appears as correct. A requirement decision and a technical defect can look similar from a screenshot.

Retest the same path after a change

When a correction is proposed, return to the recorded route and starting conditions. Compare expected and observed behaviour, then check a relevant neighbouring route. Record what you actually attempted and any conditions still untested. A code change is easier to assess when the original question survives long enough to be answered.

A precise location helps, but the steps leading to the issue may matter just as much. Choose a review method that lets you keep both when the problem depends on interaction.

Start with a report another person can follow, and compare any recurring symptom with the earlier completion record. See The Developer Needs More Than “the Button on the Right” and Did the Client Ask Again, or Did the Website Change Again?.

0

Discussion 0

What did this article make you think about?

Join the conversation

Your email address will not be published. Required fields are marked *

Saved articles

Saved in this browser.