Skip to content
Sign inRequest access

What is uMarker?

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.

Website widget

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.

Capture

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.