# How to collect bug reports from clients and testers who are not technical

> For agencies, freelancers and founders with beta users: why email threads, chat screenshots and a shared spreadsheet break down during user acceptance testing, what a working process needs, and how to let outside people report bugs without a paid seat or training.

Published 2026-11-18, about Snag.

To collect bug reports from people who are not technical, give them one place to report from the page they are on, have the tool attach the technical details so they never have to, and tell them what happened to each report.
User acceptance testing, usually shortened to UAT, is the stage where the people a product was built for (a client, a group of beta users, a colleague from another department) try it and say whether it does what they need.
Those people are good at noticing what is wrong and have no reason to know what a console log is, so the process has to do the technical part for them.

## What usually happens

**Email threads.**
A client sends "a few things I noticed" with eight issues in one message.
Replies fork, two issues get fixed, and nobody can say which of the other six are still open.

**Screenshots in chat.**
A screenshot in a chat app arrives quickly and loses everything around it: which page, which account, which browser, what was clicked before.
A week later it has scrolled out of sight.

**A shared spreadsheet.**
A spreadsheet gives every issue a row and a status, which email and chat do not.
It also asks a tester to leave the page, find the sheet, describe the bug in a cell and paste a link to an image stored somewhere else.
Each of those steps is a reason to skip a small bug.

In all three, the report holds what the person remembered and none of what their browser knew.
[What to do when a bug report has no details](https://testfinch.com/blog/client-says-it-is-broken-no-details/) lists what is missing and why asking for it afterwards is slow.

## What does a working process look like?

1. **One place to report.**
   A bug mentioned in email or chat is filed there by whoever reads it.
2. **Reporting from the page the bug is on.**
   The tester does not switch to another tool, copy an address or attach a file by hand.
3. **Evidence attached by the tool.**
   The page, the browser, the recent steps, the console errors and the failed network requests come with the report, because the tester cannot supply them.
4. **One bug per report.**
   Each report gets its own reference, status and owner, so "is this fixed?" has an answer.
5. **A status the reporter can see.**
   A tester who can see that their bug moved to fixed does not send a follow-up email asking.
6. **The reporter confirms the fix.**
   The person who found the bug is the one who knows whether the fix is what they meant.

Before a round starts, tell testers what to test, where to report, and what a good report looks like ("one problem per report, say what you expected").

## How do I let outside people report without a seat or training?

| Way in | What the tester does | Suits | Watch for |
|---|---|---|---|
| A form or template | Fills in fields and sends the result | A handful of reports, or people who can install nothing | No browser evidence unless the tester adds it by hand |
| A feedback widget on the site | Clicks a button on the page and comments | Client review of a website you build, often with no account for the client | You add a script to the site, and it works only where that script is installed |
| A capture extension with a reporter role | Installs a browser extension once, then reports from any page | Testing a web app across staging and production, where console and network evidence matters | The tester has to install the extension and sign in |

For the first row, the free [bug report template](https://testfinch.com/tools/bug-report-template/) is a fill-in form that exports Markdown and adds the browser, operating system and window size for the tester.
For the second row, [Snag vs BugHerd](https://testfinch.com/blog/snag-vs-bugherd/) and [Snag vs Marker.io](https://testfinch.com/blog/snag-vs-marker-io/) describe two widget tools and where each is the better pick.

Whichever you choose, check how outside people are charged.
A tool priced per person turns a UAT round with twelve client testers into twelve paid seats.
Look for a reporter or guest role that is free, and read what that role can see: a client should not be able to read another client's bugs or your team's internal comments.

## What a reporter can do in Snag, and what it costs

[Snag by TestFinch](https://testfinch.com/snag/) takes the third way: a capture extension, a tracker, and a reporter role for outside people.

A reporter in Snag can:

- file bugs with a screenshot or a recording from the Chrome extension, or from the Android app;
- see and follow their own bugs, and nobody else's;
- edit or withdraw their own bug while it is still in Inbox;
- comment on their own bugs and verify the fix.

A reporter cannot see other people's bugs, the full Bugs list or workspace settings.
A reporter does see every comment on their own bug, including your team's.
When you invite a reporter you can limit them to one project, so a client sees only their own project.

Reporters are free on every Snag plan and do not count against a plan's members.
Members are the people who work the board: your developers, your QA person, a project manager.
Snag Free covers 3 members, 1 project and 50 bugs a month.
Team is $39 a month for up to 15 members, with unlimited projects and bugs, so an agency with several clients pays for its own team and gives each client a project.
The [pricing page](https://testfinch.com/pricing/) has the full list.

For each bug, a reporter clicks the Snag button on the page, drags a box around the problem or records up to 90 seconds of the tab, writes one line and sends.
The extension attaches the page and browser, the last clicks and navigations, the console errors and the failed network requests.
When your team marks the bug fixed, the reporter verifies it, or sends it back with a note.

## A round of UAT with Snag, step by step

1. Create a project for the client or the release in TestFinch.
2. Invite each tester as a reporter, limited to that project.
   They get an email whose link signs them in; there is no password to set.
3. Each tester installs the Snag extension from the Chrome Web Store and signs in with their TestFinch account.
   This is the one setup step.
4. Send the short briefing: what to test, and "click the Snag button when something looks wrong".
5. Bugs arrive in the project's Inbox with their evidence.
   Your team sets severity, assigns and fixes.
6. Testers verify their own fixed bugs.
   The round is done when Inbox is empty and the fixed bugs are verified.

[Report your first bug with Snag](https://testfinch.com/docs/first-bug/) walks through the same steps with more detail, and [Capture and triage bugs with Snag](https://testfinch.com/docs/snag-capture/) says what each way of reporting captures.

## Where Snag is the wrong pick

A reporter needs an account and an installed extension.
If your reviewers will not install anything, or you want anonymous visitors to comment on a live website, a feedback widget suits you better, and a form covers the case where you expect five reports in total.
The extension runs in Chrome and other Chromium browsers such as Edge and Brave.
From a phone, the Android app files a screenshot or a screen recording, without the console and network evidence.
Snag has no two-way sync with Jira, so a team whose client insists on working in their own Jira should look at a tool built around that.
