Backend services have had observability tooling for years. APIs are instrumented, traces are propagated, dashboards are watched. The frontend, where users actually experience the product, is often a blind spot. Crashes happen and nobody knows. Slow pages get blamed on bad WiFi when the cause is a third-party script. A regression ships and the first signal is a support ticket.
Frontend observability fixes the asymmetry. The three pillars — error tracking, real user monitoring, and session replay — together produce a picture of what users actually see. Each has its own tools, costs, and operational tradeoffs. This guide is about treating them as a coherent layer rather than three disconnected purchases.
What Backend Tools Miss
A few frontend-specific failures that backend instrumentation cannot detect:
- JavaScript errors after the page loads. The server returned 200; the application crashed in the browser.
- Third-party script failures. An analytics or chat widget throws errors that disable parts of the page.
- Network issues between the user and the server. Slow DNS, packet loss, CDN misconfiguration. The backend's latency metrics are blameless because the request never arrived.
- Browser-specific bugs. Code that works in Chrome breaks in Safari. Code that works on desktop breaks on iOS.
- Render-blocking resources. A large CSS file or a slow font that delays paint without affecting any API call.
Each of these is invisible from the server side. Each can hurt experience or revenue. Each needs visibility from the browser itself.
Pillar 1: Error Tracking
JS error tracking has the best signal-to-noise ratio of any frontend observability tool. A single SDK captures uncaught exceptions, unhandled promise rejections, and console errors, groups them by stack trace, and surfaces frequency, affected user count, and recent occurrences.
The space is dominated by Sentry, with credible alternatives (Rollbar, Bugsnag, Glitchtip self-hosted). The capability bar across them is similar; the differences are pricing, source-map handling, and integrations.
The parts that matter in production:
- Source maps. Without them, stack traces are minified gibberish. Source-map upload as part of your build is the single most important configuration step.
- Release tagging. Each deploy attaches a release identifier. New errors are clearly tied to the release that introduced them.
- Error grouping. The platform fingerprints similar errors so 10,000 occurrences of the same stack trace appear as one issue.
- Sampling and filtering. Drop noisy errors (browser extensions, ResizeObserver loop overflow, etc.) at the SDK level. Otherwise they fill the dashboard and obscure real issues.
- User context. Attach a user ID or anonymized session ID to errors. "This error hit 500 users" is a more useful signal than "this error fired 500 times."
A reasonable starting filter list:
Sentry.init({
ignoreErrors: [
"ResizeObserver loop limit exceeded",
"Non-Error promise rejection captured",
/Network request failed/,
],
beforeSend(event) {
if (event.exception?.values?.[0]?.value?.includes("chrome-extension://")) {
return null;
}
return event;
},
});
Without filters, every browser extension installed by every user produces noise. With filters, the dashboard is read.
Pillar 2: Real User Monitoring
RUM captures performance data from real browser sessions. Core Web Vitals — LCP, INP, CLS — plus lower-level metrics (TTFB, FCP) and connection context.
The lightweight path is the web-vitals npm package plus a beacon endpoint that pushes the data into your existing metrics backend:
import { onCLS, onINP, onLCP, onFCP, onTTFB } from "web-vitals";
function sendMetric({ name, value, id }) {
navigator.sendBeacon(
"/api/rum",
JSON.stringify({ name, value, id, url: location.pathname })
);
}
onCLS(sendMetric);
onINP(sendMetric);
onLCP(sendMetric);
onFCP(sendMetric);
onTTFB(sendMetric);
This hits the metrics backend with one record per session per metric. From there, dashboards on p75 by page, by device class, by country.
Vendor RUM (Datadog, New Relic, Sentry Performance) adds session aggregation, automatic distributed tracing from browser to backend, and richer slicing. The cost premium is real and per-session-priced. For most teams, vendor RUM is the right answer once self-hosted gets unwieldy.
Pillar 3: Session Replay
Session replay records a reconstructed view of a user's session — clicks, scrolls, page changes, network requests. Played back, you see what the user saw.
The value is in two scenarios:
- Reproducing a bug. The error tracker shows an exception; the replay shows the user clicking three specific buttons in three seconds beforehand. Instant repro.
- UX investigation. Why is checkout abandoning at 28%? Watch ten sessions where users got to the checkout page and left. Patterns emerge that no metric would surface.
The cost is privacy. Session replay captures DOM state and user interactions. Names, emails, payment fields, anything visible. The defaults must mask aggressively — every input field should be redacted unless explicitly opted out — and the team must understand which surfaces are recorded.
Vendors here: Sentry Replay, LogRocket, FullStory, Datadog Session Replay. All offer the same core capability with varying degrees of polish in the playback UI and the masking controls.
Session replay belongs in the stack once error volumes get high enough that root-causing each error individually is expensive. For a smaller team, the error tracker alone is sufficient.
Frontend-Backend Tracing
The most underused capability in modern frontend observability is end-to-end tracing. Browser SDKs (Sentry, OTel JS) inject a traceparent header on outbound XHR / fetch requests. When the backend is OTel-instrumented, the trace stitches together — browser timing, network time, backend handler, database, and back.
A span tree from "button click" to "database query" tells stories no single layer can:
- Latency budget: how much of the 4-second page action was browser, network, backend, database?
- Failure path: where did the error originate?
- Cross-region issues: what does the slow user's path actually look like?
The configuration is mostly free. Both SDKs already inject and extract the headers; you just need to enable tracing on the frontend SDK and ensure CORS allows the traceparent header.
What to Wire on Day One
A frontend observability setup for a service with none today:
- Error tracking SDK with source maps. Sentry free tier covers small teams; self-hosted Glitchtip covers the rest. Add filters for known noise.
- Web vitals collection to the existing metrics backend. One afternoon of work for substantial visibility.
- A dashboard. Three panels: top errors by user count, p75 of LCP and INP by page, JS error rate over time.
- One synthetic check of the most-used user flow — added later in the rollout, since synthetic complements RUM rather than replacing it.
This covers the major signal sources. Session replay and frontend tracing are upgrades to add once the basics are in use.
What to Avoid
A few patterns that produce more noise than signal:
- Capturing all console.log output. Developers leave noise in production code. Capture only
console.errorand only after filtering known noisy sources. - Logging every page view to error tracking. That is what RUM and analytics are for. Error tools should contain errors.
- Alerting on individual JS errors. With browser variety, every new error appears as a new alert. Alert on aggregates ("errors affecting >100 users / 10 minutes") instead.
- Treating session replay as a debugging crutch. Recording every session is expensive and privacy-risky. Sample heavily and watch for specific scenarios.
The goal is to build a layer that surfaces the user's real experience. Each tool should produce signal proportionate to its cost — financial, operational, and privacy. The tools that fade into the background are the ones you keep.
Landing new frontend observability tooling that catches real problems without drowning the team in noise? We help teams design end-to-end visibility from browser to backend. scopeforged.com