Blog

Synthetic monitoring vs real user monitoring: what each misses, the 3 a.m. outage problem and a combined setup

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.

What synthetic monitoring sees and what it misses

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:

  • Availability on a schedule. A check every minute produces a result every minute, whether you have ten visitors or none.
  • A stable baseline. The same request from the same regions makes response times comparable over weeks. A rising trend is a real change, not a shift in your audience.
  • Things users do not trigger. Certificate expiry, DNS records, open ports, cron jobs that stopped running.
  • Pre-launch and low-traffic paths. A new endpoint or an admin login is checked before the first customer hits it.

What it misses:

  • Anything you did not script. If the check loads the homepage, a broken checkout is invisible.
  • Real device and network diversity. A probe in a data center has a fast connection and no browser extensions.
  • Client-side failures, unless you run a full browser check. A plain HTTP check sees a 200 response even if the JavaScript bundle throws on load.
  • Problems affecting only some users, for example one mobile carrier, one country or one browser version.

What real user monitoring sees and 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:

  • The actual experience across devices, browsers, networks and regions.
  • Slow pages you never thought to script, because users navigate everywhere.
  • Front-end regressions after a deploy: a heavy image, a blocking script, a layout shift.
  • Distribution, not just averages. The slowest tenth of sessions often tells a different story than the median.

What it misses:

  • Anything when there is no traffic. No visitors means no data.
  • Total outages. If the HTML never arrives, the RUM script never loads and never reports.
  • Backend-only failures with no page view attached: a webhook receiver, a background job, an API used by partners.
  • Infrastructure details like certificate expiry dates or DNS changes, which only show up once they already break things.

Why synthetic checks catch the 3 a.m. outage and RUM cannot

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.

When real user monitoring adds real value

RUM is not a replacement for uptime checks, but there are situations where it earns its place:

  • Performance work. If you are trying to make pages faster, you need to know what real users see. Common public targets for Core Web Vitals are LCP at or under 2.5 seconds, INP at or under 200 ms and CLS at or under 0.1, measured at the 75th percentile of page loads.
  • Partial outages. A CDN edge misbehaving in one region, a broken release for one browser, a third-party script that hangs for some users. Synthetic checks from a few locations can pass while a segment of users suffers.
  • Deciding what to script. RUM tells you which pages and flows real users actually hit. Those are the candidates for your next synthetic checks.
  • Incident impact. During and after an incident, RUM shows how many sessions and which pages were affected, which helps your status updates and postmortem stay factual.

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.

Synthetic monitoring vs real user monitoring at a glance

  • Trigger: synthetic runs on a schedule, RUM runs when a user loads a page.
  • Works without traffic: synthetic yes, RUM no.
  • Detects total outages: synthetic yes, RUM only indirectly through missing sessions.
  • Coverage: synthetic covers what you scripted, RUM covers what users touch.
  • Data quality: synthetic is consistent and comparable, RUM is noisy but representative.
  • Best use: synthetic for alerting and SLO measurement of availability, RUM for performance analysis and impact assessment.

A practical setup that combines both

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.

  1. Pick three to five critical paths. For example: homepage, login page, an authenticated API endpoint, a health endpoint that touches the database, and the payment or signup page. These become synthetic checks.
  2. Make each check meaningful. Check the status code and a piece of expected content, not just that a connection opened. A login page that returns 200 with an error template should fail. The guide on monitoring API endpoint uptime with status codes, latency and body checks goes deeper on this.
  3. Run checks every minute from at least three regions and require confirmation from more than one before alerting. This filters out single-route network blips; the article on reducing false positive alerts covers retries and timeouts in detail.
  4. Add the invisible parts. SSL certificate expiry, DNS records for your main domains, and heartbeats for scheduled jobs.
  5. Add a lightweight RUM beacon to your app pages, sampled if traffic is high. Send it to an endpoint you control or a RUM service of your choice.
  6. Route alerts by source. Synthetic failures page on-call. RUM regressions go to a team channel or a daily report, never to a pager at night.
  7. Review monthly. Look at the RUM data for pages and flows that are popular but have no synthetic check, and add them.

An example synthetic check plan

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 regions

To 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/login

A minimal RUM beacon

You 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.

Alerting rules: what pages someone and what goes into a report

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:

  • Page on synthetic failures only, confirmed from multiple regions.
  • Alert on RUM only with a minimum volume. For example, notify a channel if the error rate on a page doubles compared to the previous week and at least a few hundred sessions were recorded. Without a volume floor, quiet hours produce false alarms.
  • Use RUM to confirm impact, not to detect outages. When a synthetic check fires, RUM tells you how many sessions were hit and from where.
  • Treat a sudden drop in RUM sessions during business hours as a signal to look at, not as a page. It can mean the RUM script broke, a CDN is blocking it, or the site is down.

Where m0nitor fits

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.

FAQ

Is synthetic monitoring better than real user monitoring?

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.

Can real user monitoring detect downtime?

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.

How often should synthetic checks run?

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.

Does RUM slow down my website?

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.

Product

  • Pricing
  • Features
  • Integrations
  • Security
  • Free network check

Features

  • Uptime monitoring
  • Status pages
  • Alert workflows
  • Incident management
  • Dependencies
  • AI assistant
  • Global infrastructure
  • On-call schedules
  • Enterprise SSO

Use cases

  • Websites for free
  • Cron jobs
  • SSL certificates
  • Databases
  • IP blacklists
  • GDPR compliance

Resources

  • What is a status page?
  • Documentation
  • API
  • MCP server
  • Monitoring glossary
  • Free tools
  • SLA calculator
  • SSL checker
  • DNS lookup
  • Blog
  • Changelog
  • About
  • Contact

Compare

  • Free uptime monitoring
  • UptimeRobot
  • Better Stack
  • Pingdom
  • StatusCake
  • Uptime Kuma
  • Hyperping
  • Atlassian Statuspage
  • Instatus
  • Cachet
  • Freshping