Most feedback arrives as “the page is broken.” No URL, no browser, no console error, no way to
see what the person saw. Someone on your team then spends twenty minutes reconstructing the context
before they can start on the fix.
uMarker removes that step. The person reporting points at the exact element on a live page, writes a
sentence about what is wrong, and the tool captures the page around it: the screenshot, the page and
device, and — on a project set to Technical capture — the console output, the network requests, the
errors and the steps that led there. The report is actionable
the moment it lands, because the context is already attached.
It is a precision instrument, not a suggestion box. The brand metaphor is marking a location: the
mark, the dot, the dropped pin. You point at what is wrong; uMarker records where “there” is.
Almost all of it is captured automatically. There is nothing the reporter has to remember to include.
What is captured follows the project’s capture mode, set under Widget → Setup: Normal
(what new projects start on) carries the screenshot, marks, notes, page and device; Technical
adds the developer detail marked below. Both surfaces follow it alike.
An annotated screenshot of the viewport, with the marks drawn back over it in the dashboard.
Numbered pins, each with its own comment. A report can carry several marks, and every one of
them holds its own note, and in the dashboard its own discussion thread and its own done state.
The marked element. The capture tool is a DevTools-style inspector in the reporter’s hands:
hovering highlights the deepest element under the cursor with its real box model, arrow keys walk
up and down the tree, and the mark records the element’s CSS selector. The orange margin bands are
clickable too, so a report can say “this gap is wrong” about empty space.
Page and device (both modes): page URL, device type, browser and version, OS, language, screen
and window size.
Console logs (Technical): log / info / warn / error, plus uncaught errors and unhandled
promise rejections with their stack traces. The last 200 entries, captured from before the widget
itself loaded, so failures during page boot are not lost. In the Chrome/Edge extension, also the
browser’s own messages page scripts can’t see (CORS, CSP, net::ERR_*).
Network requests (Technical): every request the page made, with method, URL, status, duration
and size; failed and slow ones flagged.
Performance and environment (Technical): page-load timings, layout shift, long tasks, memory,
connection details, zoom, colour scheme and similar.
Reproduction breadcrumbs (Technical): the recent clicks, field changes and route changes that
led to the moment of capture.
Identify data: if the host site told uMarker who the visitor is, their email rides along and
shows as the reporter. Custom keys you send are stored with the report, and appear on the report
page wherever you have defined a workspace custom field with the same key (Professional and above).
Editing that field on the report changes what your team sees; what your site sent is kept, and shown
under the field.
Once a report is in the dashboard, triage adds the rest: a status, a priority, an
assignee, labels, internal comments — all of them on every plan — and a link to the issue
you opened in GitHub (Starter and above), Linear or Jira (Professional and above).
uMarker is written for two very different people, and the docs are too.
The person reporting
A visitor on your live site, your client, or a tester you authorized. Often not technical, and
often not an English speaker. The capture tool reads its language from the page they are
standing on, not from your dashboard preference. Their job: point, write a sentence, move on.
The team triaging
Product, engineering and QA working the inbox. They live in Linear, Sentry and GitHub and expect
that speed and density. Their job: find the signal, route it fast, keyboard-first.
One <script> tag on your own site. Any visitor can send feedback: no login, no extension, no
account. Shadow-DOM isolated and fail-silent, so it can never break the host page. This is the
primary path.
Browser extension
For the testers you authorize. A tester pastes a one-time connection code and captures on any
page your account covers, with a real browser screenshot rather than a rasterized DOM.
Dashboard
Where the team lives: the inbox, report detail, triage, surveys, announcements, integrations and
settings, scoped to your account and your spaces.
The widget and the extension are not two products that resemble each other: they run the
byte-identical capture tool, copied into the extension at build time because Manifest V3 forbids an
extension loading remote code. The visitor on your website and your own QA tester are using literally
the same thing. Where they differ is reach and screenshot: the extension is for people you
authorize and captures the real tab; the widget is for anyone on your site and rasterizes the
viewport.
Element inspect, numbered pins with comments, highlight and freehand pen, plus page and device
context — and console, network and errors in Technical mode — from either surface.
Triage
Labels, priority, assignment, comments with @mentions and bulk actions, plus saved views on
Starter and above, in a dense inbox as a board or a list. With a report open, j and k walk
the queue.
Engage
NPS / CSAT / CES and form surveys, in-app announcements and a hosted changelog, on Starter and
above. Publishing a changelog entry can also email the reporter back, when the report came from a
tester you authorized.
Integrate
Issues in GitHub (Starter and above), Linear and Jira (Professional and above); signed webhooks
on every plan, Slack and Telegram from Starter, Teams from Professional; and a REST API and MCP
server on the plans that include an API key.
Own your data
Hard per-account isolation and fail-closed authorization, plus a full JSON export and hard
account deletion whenever you want your data out.
AI, when you switch it on
Suggested titles, summaries, severity, duplicates and ticket drafts exist behind a provider seam.
The platform’s providers today are Groq and Google Gemini, and nothing goes to them until your
account turns AI on. An account can bring its own key instead, and then its data goes to the
vendor it chose. See below.
uMarker’s backend is one Laravel application: the API the widget and extension talk to, and the
public pages your customers see, are the same service, backed by MySQL with media in object storage.
The dashboard is a separate Vue build on its own origin, talking to that API.