Blog
Synthetic checks catch outages when nobody is online, RUM shows what real visitors experience. What each one misses and a practical setup that combines both.
In the synthetic monitoring vs real user monitoring question, the short answer is that you need both for different jobs. Synthetic monitoring runs scripted checks against your site or API on a fixed schedule, so it detects outages even when nobody is using the service. Real user monitoring (RUM) measures what actual visitors experience in their browsers, so it finds slow pages, regional problems and client-side errors that scheduled checks never touch.
The rest of this article explains what each approach sees and misses, why only one of them can wake you up for a 3 a.m. outage, and a concrete setup that uses both without doubling your alert noise.
Synthetic monitoring means a probe you control sends a request and judges the response. That can be a simple HTTP check against the homepage, a request to an API health endpoint, a TCP or DNS check, or a multi-step script that logs in. The monitoring glossary lists it next to related terms such as heartbeat monitoring and TTFB.
What it sees well:
What it misses:
Real user monitoring is a small script in your pages that collects timing and error data from each visitor's browser and sends it to a collector. Typical fields are navigation timing, Largest Contentful Paint (LCP), Interaction to Next Paint (INP), Cumulative Layout Shift (CLS), JavaScript errors, page path, device type and rough location.
What it sees well:
What it misses:
Picture a B2B SaaS where most users are in one time zone. At 3 a.m. the database fills its disk and every page returns a 500. Traffic at that hour is close to zero.
RUM produces almost nothing. The few requests that arrive fail on the server, so the browser either gets an error page without your RUM script or no page at all. The RUM dashboard shows a dip in sessions, which looks exactly like a normal night. This is the core weakness: absence of data is ambiguous. Quiet could mean healthy and idle, or completely down.
A synthetic HTTP check hits the login page every minute from several regions. The first failed check is recorded within a minute, the confirmation from other locations follows, and an alert goes out. By the time the first users arrive in the morning, someone has already fixed it or at least posted an incident.
Synthetic monitoring answers "is it working right now, even if nobody is looking?", real user monitoring answers "how is it working for the people who are using it?". Page on the first, learn from the second.
The same logic applies to anything that runs without a user in front of it: scheduled jobs, queue workers, outgoing webhooks. For those, push-based heartbeat monitoring for cron jobs fills the gap that neither page checks nor RUM cover.
RUM is not a replacement for uptime checks, but there are situations where it earns its place:
If you have very little traffic, a mostly API-driven product or no front-end team to act on the data, RUM can wait. Solid synthetic coverage comes first.
This setup works for a typical web app with a marketing site, a logged-in app and a public API. Adjust the paths to your own critical flows.
Illustrative, independent of any tool:
checks:
- name: login-page
type: http
url: https://app.example.com/login
expect_status: 200
expect_body: "Sign in"
timeout: 10s
interval: 60s
regions: [eu, us, asia]
alert_when: failing in 2 of 3 regions
- name: api-health
type: http
url: https://api.example.com/health
expect_status: 200
expect_body: '"db":"ok"'
timeout: 5s
interval: 60s
alert_when: failing in 2 of 3 regionsTo see what a single run of such a check measures, you can reproduce it from your own machine:
curl -s -o /dev/null --max-time 10 \
-w "status=%{http_code} ttfb=%{time_starttransfer}s total=%{time_total}s\n" \
https://app.example.com/loginYou do not need a large library to start. This snippet uses standard browser APIs to collect TTFB, LCP and a JavaScript error count, samples a share of page views and sends one beacon when the page is hidden:
(function () {
var SAMPLE_RATE = 0.1; // adjust to your traffic
if (Math.random() > SAMPLE_RATE) return;
var data = { path: location.pathname, lcp: null, ttfb: null, errors: 0 };
new PerformanceObserver(function (list) {
var entries = list.getEntries();
data.lcp = Math.round(entries[entries.length - 1].startTime);
}).observe({ type: 'largest-contentful-paint', buffered: true });
window.addEventListener('error', function () { data.errors++; });
document.addEventListener('visibilitychange', function () {
if (document.visibilityState !== 'hidden') return;
var nav = performance.getEntriesByType('navigation')[0];
if (nav) data.ttfb = Math.round(nav.responseStart);
navigator.sendBeacon('/rum', JSON.stringify(data));
}, { once: true });
})();On the server side, store the beacons and look at percentiles per path, not averages. A daily query for the 75th percentile LCP and the error rate per page is enough to spot most front-end regressions.
The most common mistake when combining both is alerting on RUM like it is uptime data. RUM is noisy: one user on a train with a bad connection can produce a terrible LCP. Some rules that keep it useful:
m0nitor covers the synthetic side of this setup. It runs HTTP(S), TCP, UDP, SSH, ping, DNS and SSL certificate checks from distributed probes in several regions, and confirms an outage from multiple locations before an alert fires. Heartbeat monitors cover cron jobs and other scheduled work. RUM is a separate concern: you would add a beacon like the one above or a dedicated RUM service alongside it.
Neither is better in general. Synthetic monitoring is better for detecting outages and measuring availability because it runs on a schedule regardless of traffic. Real user monitoring is better for understanding performance as users experience it. Most teams should start with synthetic checks and add RUM once they actively work on front-end performance.
Only indirectly. When the site is fully down, the RUM script never loads, so there is no data to report. You may see a drop in sessions, but that looks the same as a quiet period. For reliable downtime detection you need checks that run independently of user traffic.
For critical user-facing paths, every minute from several regions is a common choice, with confirmation from more than one region before alerting. Less critical endpoints can run less often. Match the interval to how quickly you need to know about an outage and to the availability target you promise.
A small beacon that uses built-in browser APIs and sends data with navigator.sendBeacon when the page is hidden has very little effect on load time. Larger RUM libraries with session replay or many listeners cost more. Load the script asynchronously and sample page views if your traffic is high.