Bug reports
A screen recorder for bug reports your engineers will actually watch.
Everything Loom charges for — free.
You wrote the bug report: "clicking Save sometimes throws an error." The engineer replies 4 hours later: "can't reproduce." You take a deep breath and start a 40-message Slack thread trying to figure out what "sometimes" means. By the time you've described your browser, your OS, your session state, your account type, and which specific sequence of clicks you did, it's tomorrow and nobody is happy.
Pullsy turns that thread into a 30-second recording + a chat panel where the engineer can ask the clarifying questions in line. The reporter doesn't have to retype the context; the engineer doesn't have to schedule a Zoom. The fix-recording becomes the runbook. The bug-report video becomes the answer future engineers can ask questions to.
The reproducible-bug workflow with concrete artifacts.
A bug goes from report → triage → fix → runbook → institutional knowledge. Here's the full loop using Pullsy, with what each step looks like in practice.
Reporter records the bug
30-second screen capture showing the misclick: open the app, navigate to the broken screen, click the failing button. Pullsy auto-generates a transcript + Ask-this-video panel.
// In your bug template, paste the Pullsy link:
// Bug repro: https://pullsy.online/v/abc123
// (engineer can ask questions inline below the video)Engineer asks clarifying questions
Instead of a 20-message Slack thread or a Zoom call, the engineer types questions into the Ask-this-video panel. Each answer is timestamped back to the recording. The reporter answers in plain English — "yes, on the latest Chrome," "yes, with a fresh session" — and Pullsy timestamps each answer.
// Engineer: "what browser exactly?"
// Reporter: "Chrome 127 on macOS, latest stable"
// Reporter: "and yes, hard refresh — same result"
// Each answer is anchored to a moment in the recording.Reporter sees the engineer watched
Pullsy's view analytics show the reporter that the engineer watched to 95% and asked three clarifying questions. The reporter knows the engineer is actually engaged, not rubber-stamping.
// Pullsy analytics on the bug video:
// 1 viewer (engineer@team.com)
// 95% completion, 3 questions asked
// "did you try in incognito?" at 0:42Engineer records the fix walkthrough
60-second walkthrough of the patched code: "here's the off-by-one, here's the test I added, here's the deploy." Pullsy generates the auto-summary and chapter list.
// Patch commit message:
// fix: off-by-one in pagination cursor
//
// Fixes: https://pullsy.online/v/abc123
// Walkthrough: https://pullsy.online/v/fix789
// (PR description embeds both Pullsy links)Fix becomes the runbook
Pullsy's auto-guide export turns the fix-recording into a numbered step-by-step procedure. The support team pastes it into their KB; future on-call engineers have the answer without re-reading the PR.
// Support KB article:
// "How to recognize and fix the pagination off-by-one"
//
// Step 1: Check the cursor — must include offset, not page
// Step 2: Validate the query param is a number
// Step 3: ... (auto-generated from the recording)
//
// See the recording at https://pullsy.online/v/fix789Future engineers can ask the original recording
Three months later, a junior engineer hits the same area of the codebase. The original bug-recording and the fix-recording both have Ask-this-video panels. The junior types "why did we do it this way?" and gets an answer from the fix-recording's transcript — same source of truth, no need to schedule a meeting.
// Junior engineer:
// "why do we validate the cursor as a number before querying?"
//
// Answer (from the fix-recording transcript, at 2:14):
// "Because SQLite returns NULL silently if the cast fails, and
// that propagates as an empty result set instead of an error."Loom vs Pullsy for bug-report workflows.
| Workflow need | Loom Free | Loom Business | Pullsy Free |
|---|---|---|---|
| Quick screen recording for the repro | Yes, but 5-min cap and watermark | Yes | Yes, free, no watermark |
| Engineer asks clarifying questions inline | No — Slack thread required | No — Slack thread required | Yes — Ask-this-video panel |
| Reporter sees the engineer watched | No analytics | Yes | Yes, free |
| Fix-recording → runbook auto-generated | No | No | Yes, free |
| Future engineers can ask the original video | No | No | Yes, free |
| Custom domain so links look internal | No | Yes, paid | Pro tier (~€9/mo) |
Ask-this-video — inline clarifying questions.
The reporter records the bug once. The engineer\'s clarifying questions happen below the video — no Slack thread, no Zoom call, no "wait, what OS again?" The transcript anchors each answer to the right moment in the recording. Loom doesn\'t have this feature at any tier.
Free view analytics — so reporters know their bug matters.
The reporter sees that the engineer watched to 95% and asked three follow-ups. That\'s the difference between a bug report that gets rubber-stamped and one that gets triaged properly. Loom gates the same data behind Business (~$18/user/mo).
Recording → guide — so the fix becomes the runbook.
Pullsy\'s auto-guide export turns the fix-recording into a numbered procedure. Support, on-call, and future engineers have the answer in the KB instead of in someone\'s head. Loom has no equivalent at any tier.
Frequently asked questions
Does it work on staging environments?
Yes. Pullsy records whatever is on your screen — staging, local dev, production (with sensitive data redacted, see below). The recording is a standard video file your browser captures via the Web screen-capture API. It works the same in any environment.
Can it capture the network tab or browser DevTools?
No — Pullsy captures the visual output of your screen, not the underlying network calls or console output. If you need to share a network trace, attach a HAR export or a screenshot of DevTools inside the recording. For backend bugs, the recording can narrate what was happening in the logs while showing the relevant UI state.
Can I redact sensitive info from a bug-report video?
Pullsy's recording is whatever you captured — there's no auto-redaction. The standard pattern is to record, then either edit in a video tool before sharing, or simply pause recording while typing credentials. Pro tier adds custom-domain share URLs so a bug-report video can sit on your team's domain rather than pullsy.online.
Does the engineer need a Pullsy account to ask the recording a question?
No. The engineer clicks the share link, watches the video, and types into the Ask-this-video panel below. No account, no login. The reporter (you) sees the question and the answer in your recording's analytics view.
What about log capture? Can Pullsy grab the application logs while I record?
Not automatically. Pullsy captures screen + audio. If you want the log output as part of the bug-report video, either (a) display the logs on screen in a split-pane terminal alongside the UI, or (b) paste the relevant log snippet into the ticket description next to the Pullsy link. Most teams find (a) is enough — the engineer pauses the video at the log panel and reads it.
Is Pullsy affiliated with Loom?
No. Loom is a trademark of Atlassian. Pullsy is an independent product not affiliated with or endorsed by Loom. Plan details above are dated to July 2026 from Loom's public pricing pages.
Reproduce the bug. Ship the fix. Document both.
No install, no signup, no watermark. Free.
Loom is a trademark of Atlassian. Pullsy is not affiliated with or endorsed by Loom. Loom plan details reflect Loom's public pricing pages as of July 2026.