# My client says the site is broken and sends no details: what to do

> A client or user says the site is broken and sends no page, no steps and no error. The six things a developer needs to reproduce a bug, why asking the reporter for them rarely works, a checklist to copy, and how capturing at the moment of the bug removes the asking.

Published 2026-11-18, about Snag.

When someone reports "it's broken" with nothing else, you need six things before you can reproduce the bug: the page and the steps, what they expected, the console errors, the failed network requests, the browser and screen size, and a picture or recording.
Reproducing a bug means making it happen again on your own computer, and until you can, any fix is a guess.
You can ask the reporter for those six things, which is slow and usually comes back incomplete, or you can give them a way to report that collects the six at the moment the bug happens.

## What does a developer need to reproduce a bug?

| What you need | What it tells you | Can the reporter give it from memory? |
|---|---|---|
| The page and the steps | Where the bug is and how to get there | Partly: people remember the last click and forget the ones before it |
| What they expected, and what happened | Whether it is a bug, a misunderstanding or a missing feature | Yes, and only they can |
| Console errors | The error the page logged when it broke, often with the file and line | No: a reporter who is not a developer has rarely opened the console |
| Failed network requests | Which request to the server failed and the status it returned | No |
| Browser, operating system and screen size | Whether the bug happens only in one browser or at one window width | Rarely: "Chrome, I think" |
| A screenshot or recording | What the screen showed | Yes, though often cropped so the address bar and the error are cut off |

The console is the browser's log of what the page's code reported while it ran, including errors.
A network request is one call from the page to a server, such as saving a form; a failed one has a status like 500 (the server hit an error) or 403 (the server refused).
Two of the six rows are things a person knows.
The other four are things the browser knows, and the browser forgets most of them when the tab is closed or reloaded.

## Why does asking the reporter for details fail?

**The moment has passed.**
By the time your reply arrives, the tab is closed.
The console errors and the failed request went with it.
The reporter would have to make the bug happen again to collect them, and many bugs do not happen on demand.

**The reporter does not know the words.**
"Open the developer tools and copy the red lines from the Console tab" is a reasonable request to a developer.
To a client it is a request to do something unfamiliar in a part of the browser they did not know existed.

**Every question is another wait.**
You ask which page and wait for the answer, then ask which browser and wait again.

**People report less when reporting is work.**
A reporter who gets a list of questions back each time may stop reporting small things, and those bugs stay unreported.

## What should I ask for when I have to ask?

When the report is already in your inbox, ask once, for everything, in words that need no training.
Copy this:

```text
Thanks for flagging this. To find it quickly I need a few things:

1. The address of the page (copy it from the address bar).
2. What you did right before it went wrong, click by click.
3. What you expected to happen.
4. What happened instead, with the exact wording of any message.
5. A screenshot of the whole browser window, not only the part that looks wrong.
6. Which browser you use (Chrome, Edge, another) and whether you were on a computer or a phone.
7. Does it happen every time, or only sometimes?
```

Item 5 asks for the whole window because the address bar, the time and any error banner are often outside the part a person crops to.
The list leaves out console errors and failed requests on purpose: asking a non-technical person for them in a first reply usually stalls the thread.
If you still need them after the answers arrive, [How to get console logs from a user's browser](https://testfinch.com/blog/get-console-logs-from-a-user-without-devtools/) compares the ways to do it.

The free [bug report template](https://testfinch.com/tools/bug-report-template/) has the same sections as a form.
A reporter fills it in, selects "Use this browser's details" to add the browser, operating system and window size, and copies the result into an email or your tracker.
Nothing typed into the form leaves their device until they copy or download it.

## How do I reproduce a bug I cannot see?

1. Open the exact address the reporter gave, in the browser they named, signed in as an account with the same role.
2. Follow their steps with the same data.
   If they typed a promo code or uploaded a file, use that code or a file of the same kind.
3. Match the window size.
   A button that is hidden at 1280 pixels wide is visible on your larger monitor.
4. Keep the developer tools open on the Console and Network tabs while you do it, so the error and the failed request are recorded when the bug appears.
5. If it does not happen, change one thing at a time: a fresh private window, a different account, a slower connection.

When none of that works, the bug depends on something only the reporter's browser has: their account's data, an extension, a cached file.
At that point you need the evidence from their browser, captured while the bug is on their screen.

## How does capture at the moment of the bug fix this?

A capture tool is a browser extension that keeps the recent steps, console errors and failed requests in memory while a person browses, and attaches them to the report when the person clicks "report".
The reporter supplies the two things only they know: a line about what they expected, and a circle around what looks wrong.

The same promo code bug, reported both ways:

```text
From: client
Subject: checkout broken

The discount isn't working. Can you look at it today?
```

```text
Promo code SAVE10 rejected at checkout

Page:       https://shop.example.com/cart
Browser:    Chrome on macOS, window 1440 x 900
Steps:      Open the brass pen, Add to cart, Open the cart,
            type in Promo code, click Apply
Console:    TypeError: Cannot read properties of undefined (reading 'percent')
Network:    POST /api/cart/promo  500
Screenshot: the cart, with "This code is not valid" circled
```

The reporter wrote one sentence both times, and a developer can start on the second report without a reply.
[Bug reports developers can act on](https://testfinch.com/blog/bug-reports-developers-can-act-on/) goes through each part of a report like the second one.

## Where Snag fits

[Snag by TestFinch](https://testfinch.com/snag/) is a capture tool of this kind with the tracker included.
The Chrome extension files a marked-up screenshot or up to 90 seconds of recording, with the page and browser, the last clicks and navigations, the console errors and the failed network requests attached.
The bug lands on a board your team reads, and a coding agent can read the same bug with its evidence.
A client or tester joins as a reporter, who files bugs and sees only their own; reporters are free and do not count against a plan's members.
Snag Free covers 1 project and 50 bugs a month.

Snag captures when a person reports, so it does not catch an error nobody notices.
The reporter has to install the extension in Chrome or another Chromium browser and sign in from an emailed invite.
For a visitor you cannot ask to install anything, use the checklist and the bug report template.
[Collecting bug reports from clients and testers who are not technical](https://testfinch.com/blog/collecting-bug-reports-from-non-technical-clients-and-testers/) covers setting the process up for a whole group.
