Skip to content
Sign inRequest access

How uMarker works

uMarker is one Laravel application with two faces (a dashboard and an API), plus a website widget and a browser extension that feed it. Feedback flows through the same pipeline no matter which surface captured it.

  1. Capture: in the browser. The website widget or the browser extension opens the capture tool directly: the reporter inspects an element or draws on the page, writes a comment on each pin, and hits Review. Only then is the screenshot taken, of a clean page with the tool’s own chrome hidden; the reporter then checks each comment against that shot and presses Submit for review to send it. The context is gathered at the same moment: the page and device always, and — on a project set to Technical capture — console, network requests, errors, performance and breadcrumbs too. Masking is a per-project switch that is off until you switch it on; when it is on, it runs in the page, before the screenshot exists.

  2. Ingest: on the server. The report is POSTed to the API. uMarker re-validates authorization server-side and fails closed: the client’s view of “am I allowed here” is only advisory. The widget’s request must resolve a live public key for a published project and arrive from one of that project’s allowed domains; the extension’s request must carry a valid token and the tester must still be authorized for that project. Input is allowlisted at this trust boundary — a field with no rule is dropped rather than stored — and the capture payload is bounded: 5,000 characters of comment, at most 50 pins, a 12 MB ceiling per screenshot, and the console log (200 entries), browser metadata (16 KB) and enrichment lists all re-capped on the server rather than taking the widget’s word for its own limits. For a project on Normal capture, any technical data that arrives anyway is discarded. Identity data your own page attaches to the widget is capped at 16 KB.

  3. Triage: in the dashboard. The report lands in the inbox with status new. A triager opens it, reads the attached context, and acts: set priority, labels and an assignee, leave a comment with an @mention, resolve individual pins, or push the report to an issue tracker.

  4. Resolve: the status moves through new → in_progress → waiting → resolved as the work happens (plus archived for what you are not doing). Every change is attributed in the audit log: who changed what, and when. If the report is linked to a tracker issue, closing the issue moves the report for you.

  5. Close the loop (optional): publish the fix as a changelog entry linked back to the report — publishing the changelog needs a plan that includes it, which means Starter and up. On that publish you can tick notify the reporter; only then does one email go out, in the brand’s language. The tick is offered only when the report came from a signed-in extension tester, whose address uMarker has verified. A report from the public snippet carries no verified address, so nobody is emailed for it.

The widget and extension capture in the browser; the Laravel app authorizes, ingests and stores; the dashboard triages. MySQL holds the data; an object-storage disk holds the media.

BROWSER (the reporter's) LARAVEL APP
┌───────────────────────┐ ┌──────────────────────────────────┐
│ Website widget │ │ ┌────────────────────────────┐ │
│ • <script> loader │──── HTTPS ───▶│ │ API │ │
│ • public key │ JSON │ │ resolve key → check │ │
│ • shared capture UI │ │ │ domain → gate → ingest │ │
└───────────────────────┘ │ │ (re-validated, fail-closed)│ │
┌───────────────────────┐ │ └──────────────┬─────────────┘ │
│ Browser extension │──── HTTPS ───▶│ │ │
│ • connection token │ JSON │ ┌──────────────▼─────────────┐ │
│ • shared capture UI │ │ │ Dashboard │ │
│ • real tab capture │ │ │ inbox · triage · engage │ │
└───────────────────────┘ │ └────────────────────────────┘ │
│ │ │
│ MySQL ◀──┴──▶ object │
│ storage │
└─────────────┬────────────────────┘
│ queued jobs (dispatched after the write)
▼
email · Slack / Teams / Telegram ·
signed webhooks · trackers (by plan)
[in-app bell: written on the request]

The same platform runs feedback in both directions.

Reactive: capture → triage → resolve

Someone hits a problem and reports it. This is the core loop above: a contextual report is captured, triaged in the inbox, and resolved, optionally closing the loop back to the reporter.

Proactive: ask, then tell

You reach out first. Surveys (NPS / CSAT / CES and form surveys) collect structured answers, and announcements push “what’s new” into the widget. Both share the account’s label taxonomy, so responses land in the same triage vocabulary.

The two meet in Insights: a read-only rollup of the status split, a 14-day report trend, the top labels across feedback and survey responses, and survey headline scores, scoped to a space or a single project.

  1. Storage: every screenshot is written through a filesystem disk, never a raw path, and never exposed as a public bucket URL. Opening a report streams the image through the app, checked against the account, the project and your role. Two paths use a signed link instead, because neither reader can carry a token: the board’s and the media gallery’s thumbnails, signed for six hours, and the screenshot uMarker embeds in an issue-tracker ticket, which people outside your account open — that one is signed for as long as the screenshot is kept, and on a plan that sets no media-retention limit (Enterprise) it does not expire at all. Screenshots have their own retention window, separate from the report’s: the image can be cleared while the report and its discussion are kept.

  2. The queue: ingestion does not wait on the slow side effects. Emails, channel messages and tracker calls run as queued jobs, dispatched after the report row is committed. The one thing that is not queued is the in-app bell: its row is written on the request itself, so the bell updates with no worker running — except in bulk triage, where nobody is watching it mid-request and it joins the queue with the rest. Each recipient and each channel is isolated, so one rate-limited mail provider cannot silently swallow the Slack message for the same report. Which destinations you can use follows the plan: signed webhooks are on every plan, Free included; email, Slack, Telegram and GitHub issues start at Starter; Microsoft Teams, Jira and Linear at Professional.

  3. The AI seam: an optional layer that can draft a title, summary, severity and labels and flag likely duplicates. Its output is advisory: a human confirms, edits or dismisses it. It is off until you turn it on: the platform’s providers today are Groq and Google Gemini, but the account’s plan has to include AI and the account has to consent separately before anything is sent.