uMarker is designed to be safe to deploy on a client’s real site. That constraint shapes the
whole architecture: the capture surface runs inside arbitrary third-party pages, and the dashboard
holds many tenants’ data in one database. Exactly one of the project’s twelve founding principles is
marked non-negotiable — security and privacy — and it names its trust boundaries by hand: input
validation, tenant and workspace isolation, PII masking at capture, hashed or encrypted secrets. The
rule that follows is blunt: access decisions fail closed. A project with no listed domain serves
the widget nowhere, and an account whose plan key names nothing resolves to the smallest tier rather
than the largest.
This page is the map. Each capability below has a dedicated page with the exact mechanism, and the
last section lists the things a reviewer will ask about that uMarker does not have.
Every tenant-owned record carries an account_id. Most are filtered automatically by a global
Eloquent scope that resolves the current account from the authenticated principal; the two auth
principals and the billing, audit, sent-mail, support-message and coupon-redemption tables are
filtered by an explicit predicate at each call site instead. Either way, cross-tenant access is
answered 404, never with another tenant’s rows. See
Tenancy & data model.
Fail-closed authorization
The client’s view of “am I allowed here” is advisory. Every ingest and dashboard request is
re-validated server-side and denied by default. See Roles & access.
In-browser redaction
Masking runs in the page, before the screenshot is taken, never as a server-side cleanup.
Secret-looking query-string values are blanked on every project; masking the values people type
and the regions you mark is a per-project switch that ships off. See
PII redaction.
Retention that actually runs
Setting a retention window for reports is an Agency-and-above capability; on those plans a
nightly job deletes reports past it, media included, and on every other plan no report is deleted
by age. A second job clears stored media older than the plan’s media window — 30 days on Free,
730 on Agency, unlimited on an Enterprise term — while keeping the report. See
Data processing.
Export and erasure
A full JSON export of everything the account owns (never a secret), and a hard delete that
reaches the rows and the stored files. Both are buttons, not support requests.
SSRF-safe outbound
Tenant-supplied webhook and channel URLs must be public HTTPS; hosts that resolve to private,
loopback, link-local or reserved IP ranges are refused. See Channels.
Escape-first rich text
Author-written announcement and changelog bodies are HTML-escaped first, then a tiny markdown
allowlist is applied: no raw HTML, script or style can survive.
Visible support access
When our support staff sign in as one of your members, it is recorded and shown to you, in
your own account settings, with the time and the window it lasted.
An account is the data-isolation boundary. Most tenant-owned models use a BelongsToAccount
trait that adds a global scope filtering every query by the current account_id, and auto-fills
account_id on create. The current account is resolved from the authenticated principal: a dashboard
user, or a widget/extension identity on the token guard, both of which carry account_id. The two
auth principals and the billing, audit, sent-mail, support-message and coupon-redemption tables carry
account_id without the trait, and are filtered by an explicit predicate wherever they are read. In
console and queue contexts there is no request user, so nothing is auto-scoped and callers must set
the account explicitly.
Inside an account, two further layers narrow reach: workspaces (a request scoped to one workspace
via the X-Workspace-Id header sees only that workspace’s rows) and per-project access, where a
member reaches exactly the projects they are attached to. Full detail in
Tenancy & data model.
The extension and the snippet decide whether to show themselves on the client, but that decision is
never trusted for data. There is one config endpoint per surface, and each re-evaluates visibility
from scratch on every call. The snippet’s resolves the public key to a project, confirms that
project is published on the snippet surface and its account is not suspended, and checks the page’s
origin against the project’s allowed domains — it carries no caller identity, so that domain list is
what stops a leaked public key from serving the widget somewhere else. The extension’s resolves
the page’s own host to a project inside the signed-in tester’s account, confirms the project is
published on the extension surface, and confirms that tester is authorized for it. Either way,
anything else returns hidden. The ingest endpoint independently re-resolves the project and re-checks
the origin before storing a report. Revoking an extension identity flags it and deletes its active
tokens on the spot, so cached client authorization can’t keep the widget alive.
Where it happens carries no condition: every masking and text-redaction step that runs at all runs
in the reporter’s own browser, before the screenshot is rendered and before the payload is
posted. There is no
server-side cleanup pass, so whatever is not masked on the device reaches us exactly as captured.
How much is masked depends on one per-project switch, and a new project ships with it off:
On every project, always. Query-string values whose name suggests a secret (token,
session, sig, email, phone and friends, including accessToken-style camelCase) are
blanked the moment a URL is recorded, so the raw value is never even held in memory.
Only with Auto-redact sensitive fields on (Project → Widget → Setup → Privacy): the
values typed into form fields and anything matching a CSS selector you list as always-sensitive
are masked before the screenshot is rendered, and secret-shaped strings in console lines,
breadcrumbs and request URLs (captured only in Technical mode) are replaced with [redacted] as
the payload is assembled.
Until you turn it on, the screenshot carries whatever the visitor had typed.
The browser extension runs the same widget engine as the snippet, so it reads the same switch and
applies the same masking and text redaction. Console, network and breadcrumb text exists only on a
project set to Technical capture; on a Normal project nothing technical is recorded, and the
server discards it if it arrives anyway. Detail, including the honest limits, in
PII redaction.
Two helpers guard the places where tenant-supplied content becomes an outbound request or rendered
markup:
Outbound URLs (notification channels, webhooks, a Jira base URL) are validated at write time:
the URL must be https, and its host must resolve only to public IP addresses. Private
(RFC 1918), loopback, link-local (including the cloud-metadata address 169.254.169.254)
and reserved ranges are refused, decimal and octal spellings included, and delivery jobs
additionally disable redirect-following.
Rich bodies (announcements, changelog entries) are rendered through an escape-first markdown
subset: the input is HTML-escaped first, so no author-supplied HTML, <script>, style or event
handler can survive, and only a fixed set of markers (paragraphs, lists, bold, italic, code, and
http/https links decorated with rel="noopener nofollow") is turned into tags.
REST API keys are stored only as a SHA-256 hash with a short non-secret prefix; the plaintext
(md_live_…) is shown once at creation and never stored, so a database read never yields a usable
key. Tracker credentials and channel secrets are encrypted at rest and hidden from serialization —
including the channel URL, which for Slack and Teams is the credential, and Telegram’s bot token,
stored with its chat (and topic) — write-only once saved, like the rest. One column is the
exception and is worth naming: a tracker’s inbound webhook token is the lookup key of its status-back
URL, so it is hidden from serialization but stored in plaintext. Provider error text is scrubbed
before it is stored: on the tracker paths — the queued one and the manual button alike — URLs and
credential-shaped strings are stripped, and channel delivery strips the webhook URL out of the
failure it records. The exception branch of the Test connection button is the one path that
stores a provider message unscrubbed.
Access tokens are pruned when they go idle (90 days by default, configurable) rather than on an
absolute clock, so a session someone uses daily is never cut off and a laptop nobody has opened since
last season stops being a key. Changing a password ends every other session.
Security-relevant events are written to audit_logs through a single Audit helper that records the
action, the acting user or extension identity, the subject, any operator wearing that identity, and a
timestamp. Rows fall into two classes, and the difference matters before you rely on one:
Compliance — support sign-ins, member suspension, account and report deletion, plan and
entitlement changes, role and invitation changes, and issuing or revoking an extension identity.
These are written whatever the platform settings say, are exempt from the write ceiling, and are
kept for a year by default.
Activity — sign-ins, REST key issuance and revocation, widget key rotation, status and
assignment changes, and ordinary content edits. An operator can switch this class off, a write
burst can shed it (the gap itself is recorded), and a nightly prune deletes it after 30 days by
default.
Whatever the table holds at the time is included in your data export.
A reviewer’s time is better spent on the gaps than on the list above, so here they are:
No signed DPA
There is no data-processing agreement to countersign yet, and no contractual subprocessor list.
The roles are clear (you are the controller, uMarker is the processor), but the paper is not
written. See Data processing.
No certification
No SOC 2, no ISO 27001, no published penetration-test letter. The technical controls on this page
are real and tested; none of them has been audited by a third party.
No announced hosting region
The deployment region is an operator setting and has not been decided and published. Do not read
in-Kingdom or EU residency into this documentation; neither is promised.
AI is off until your account turns it on
Nothing from your account reaches a model unless your plan includes AI and an account admin switches
consent on. Then report text only — never screenshots — goes to a provider in our chain (Groq or
Google Gemini). See Subprocessors.
Found a security issue? Write to security@umarker.com (or
support@umarker.com if you hear nothing back) with the URL, the steps to
reproduce and the impact. We acknowledge within 5 business days, and ask you not to publish details
until it is fixed or 90 days have passed, whichever comes first. We will not pursue legal action
against good-faith research that uses your own account and stops at the first access to someone else’s
data. The full policy is on the security page, and both
addresses are published in security.txt.