There is a category of frontend bugs that no amount of internal testing finds. The third-party tracking script that times out only on flaky mobile networks. The font that loads instantly in your dev machine but blocks rendering on a Chromebook with 50 tabs open. The infinite-loop that triggers only when an ad blocker happens to remove a specific DOM node.
Real User Monitoring (RUM) is how you find these. Instead of synthetic checks from controlled environments, RUM collects performance and error data from actual browser sessions of real users. You see what your worst-case user actually experienced, not what your monitoring infrastructure pretends to be.
This guide covers what RUM measures, the practical tradeoffs of vendor vs self-hosted options, and where teams typically over- or under-invest.
What RUM Measures
A typical RUM payload contains three classes of data, sent from the browser to a collector.
Performance metrics — primarily Core Web Vitals.
- LCP (Largest Contentful Paint) — when the largest visible element rendered. Google's primary signal for perceived load speed.
- INP (Interaction to Next Paint) — the slowest interaction the user had during the session. Replaced FID in 2024 as the standard responsiveness metric.
- CLS (Cumulative Layout Shift) — how much the page jumped around during loading. A measure of visual stability.
- FCP (First Contentful Paint) — when the first content appeared. Earlier than LCP, useful as an early-stage indicator.
- TTFB (Time to First Byte) — server response time as seen by the browser. Useful for bridging backend latency and total user-perceived load.
JavaScript errors — uncaught exceptions, promise rejections, console errors. The most-cited reason teams adopt RUM. Errors include stack traces, browser context, user agent, and (with care) a redacted view of application state.
Session context — connection type, viewport size, country, device class, browser, page URL, referrer. Without this, performance data is unactionable; you cannot tell if your LCP regression is a code change or a sudden influx of mobile users.
Mature RUM platforms add session replay, frontend tracing (linking browser performance to backend spans), and custom events ("checkout button clicked"), but the three categories above are the load-bearing parts.
Vendor vs Self-Hosted
The RUM market is dominated by three categories of vendors.
Full APM platforms — Datadog, New Relic, Dynatrace. RUM is one product alongside backend tracing, infrastructure monitoring, and logs. The benefit is a single backend; the cost is per-session pricing that scales aggressively.
Frontend specialists — Sentry, LogRocket, Raygun. Often start from error tracking and add performance. The benefit is depth in JS error workflows; the cost is duplicating data already collected elsewhere.
Open-source / self-hosted — Glitchtip, Plausible (limited), or building your own with the W3C web-vitals library + navigator.sendBeacon + Prometheus / ClickHouse. The benefit is per-session cost approaching zero; the cost is operational burden, especially for session replay and JS error grouping.
A rough decision framework:
- Small team, traffic under 1M page views/month → use the existing APM if one is in place. Datadog RUM at this scale is in the noise.
- Medium team, 10–100M page views/month → cost matters. Either a frontend specialist (Sentry) for errors plus a lighter Core Web Vitals collector, or a self-hosted stack.
- Large team, 100M+ page views/month → self-hosted starts to pay off. Vendor pricing at this volume is six- to seven-figure.
Most teams that move off vendors do so because of one of three reasons: cost, data residency, or the limits of vendor query languages on high-cardinality fields.
What "Real User" Actually Means
A subtle point that affects how you read RUM data: "real user" is a population, not a single experience. Two questions worth asking up front:
- Who is in the sample? Bots, internal QA, and synthetic scripts that aren't excluded inflate the numbers. Filter user agents and known IP ranges before doing anything else with the data.
- What is the percentile distribution? The average page load time is rarely useful. p75 and p95 surface the experience of users on slower devices and networks. Optimization that improves the p95 by 30% rarely shows up in the median.
Most RUM dashboards default to p75 because that is what Core Web Vitals scoring is based on. Stick with it for consistency.
Sampling and Volume
RUM data scales with page views. At a million page views per day, even a minimal payload (1KB per beacon) is gigabytes of ingress, and the backend stores time series for each unique combination of page, device, country, browser version, and so on. Costs and query latency follow.
The answer is sampling. Two common approaches:
- Random sampling. Each session has an N% chance of being recorded. Simple, but you lose proportional data across all segments — including the slow-tail experiences you most want to keep.
- Stratified sampling. Always keep sessions with errors. Sample slow sessions (e.g., LCP > 2.5s) at a higher rate. Sample everything else at a lower rate. Catches outliers without paying for the median.
Most vendors handle this for you with default configurations. If you self-host, sampling is one of the first decisions to get right.
Bridging Frontend and Backend
The most valuable insight from RUM is rarely the frontend metric alone — it is the link to the backend trace. A user's LCP was 4.2 seconds; the underlying API call was 3.8 seconds; the database query that drove it took 3.6 seconds. Each layer adds context, and isolating problems means following the chain.
Modern RUM SDKs propagate W3C trace context headers on outgoing requests. When the backend is OTel-instrumented, you get an end-to-end trace from the browser click to the database row. This is a setup step that takes an afternoon and pays off forever — many teams have RUM and tracing in production for years without ever linking them.
Privacy and PII
RUM payloads can include URLs with query parameters, form values, console logs, and screen recordings. All of these are obvious vectors for accidentally collecting PII.
The defaults to set on day one:
- Strip query parameters or hash them before sending.
- Redact input values; never capture credit card or password fields.
- For session replay, mask all input fields by default and explicitly opt-in non-sensitive ones.
- Honor Do Not Track and Global Privacy Control signals.
The cost of getting this wrong ranges from awkward audit findings to regulatory fines. Set up redaction before users see the page, not after a compliance review surfaces the leak.
A Practical Starting Setup
If you have no RUM today:
- Add the W3C
web-vitalslibrary and send Core Web Vitals to your existing metrics backend. This is one afternoon of work. - Add a JS error tracker — Sentry's free tier or a self-hosted alternative — and wire source maps for readable stack traces.
- Build one dashboard per primary user flow: a homepage panel, a signup panel, a checkout panel. Show p75 LCP, p75 INP, JS error rate, and session count over time.
- Set alerts only after a baseline is established. RUM data is noisy on day one; thresholds based on real distributions, not aspirational targets, prevent alert fatigue.
This covers most of the value of a paid RUM platform for a fraction of the cost. Reach for the vendors when you outgrow it — when you need session replay, frontend tracing, or correlation across millions of sessions.
Figuring out whether your frontend is fast for the users that matter? We help teams set up RUM that catches real regressions without drowning in noise. scopeforged.com