---
title: "Synthetic monitoring vs real user monitoring | Logdash"
description: "Synthetic checks catch outages with zero traffic, RUM shows what real visitors see. What each one misses, where APM fits, and which to set up first."
url: https://logdash.io/learn/synthetic-monitoring-vs-real-user-monitoring
---

# Synthetic monitoring vs real user monitoring

Synthetic monitoring sends scripted requests to your app on a schedule, so it catches an outage at 3am with zero visitors, while real user monitoring records what actual visitors experience in their browsers, so it catches slow pages and errors no script ever hits.

Logdash is synthetic monitoring. It sends HTTP requests to your URL from its own servers and alerts you when the answer is wrong. It is not real user monitoring and it does not run in your visitors' browsers. Both are worth having, and they fail in opposite directions, so it helps to know which hole each one leaves.

## What is synthetic monitoring

A robot visitor on a timer. The simple kind sends one HTTP request and records the status code and response time. The heavy kind drives a headless browser through a script: log in, add to cart, pay. Logdash does the simple kind, one GET per check, every 5 minutes on the free plan, every minute on Builder and every 15 seconds on Pro. It needs no traffic, so it works the same at 3am as at noon.

 Synthetic: one scripted request 

```bash
curl -sS -L -o /dev/null -m 10 \
  -w '%{http_code} in %{time_total}s\n' \
  https://example.com/health

# 200 in 0.084s
```

## What real user monitoring records

A script in your pages measures every real visit, such as how long the largest element took to paint, how fast the page reacted to a click and how much the layout jumped, then sends it home. That is per device, per country and per page, which no single check can give you. The catch is that it needs visitors. No traffic, no data, and an app that is fully down sends nothing at all.

 Real user monitoring: what each visit reports 

```javascript
import { onCLS, onINP, onLCP } from 'web-vitals';

function send(metric) {
  const body = JSON.stringify({
    name: metric.name,
    value: metric.value,
    page: location.pathname,
  });
  navigator.sendBeacon('/rum', body);
}

onCLS(send);
onINP(send);
onLCP(send);
```

### Synthetic (Logdash) vs real user monitoring (RUM)

| Feature                                  | Logdash                                      | RUM                                                  |
| ---------------------------------------- | -------------------------------------------- | ---------------------------------------------------- |
| Where the data comes from                | A request from Logdash servers on a schedule | Every real page view, from the visitor's browser     |
| Full outage at 3am, no traffic           | Caught within one interval                   | Silent, no visitors means no data                    |
| Slow pages on a phone in another country | Not visible, one request from one place      | Visible per device, country and page                 |
| Front-end errors and layout shift        | Not visible                                  | Measured on every visit                              |
| Setup                                    | Paste a URL                                  | A script in every page and an endpoint to receive it |

### When RUM is the better pick

- You care about Core Web Vitals. Google assesses them from real Chrome visits, not from lab or synthetic tests.
- The app is up and users still say it is slow. Only field data shows which page, which device and which country.
- You already host on Vercel. Speed Insights is free on every plan, with 10,000 events over a rolling 30 days and one overall Real Experience Score.

## Synthetic monitoring vs APM

APM instruments your server code and traces each request through handlers, queries and outbound calls. It tells you which query made the endpoint slow. Synthetic monitoring tells you the endpoint was slow, or gone. APM cannot report a dead server, because the agent dies with it. Logdash is not APM: it has logs and metrics from eight SDKs beside each check, and no distributed tracing. If you need a scripted login flow tested, that is a browser check: Checkly runs Playwright scripts and its Hobby plan includes 1,000 browser runs a month.

## Which one first

Synthetic. It covers the worst case, fully down, with zero traffic and one URL. Add RUM once you have enough visitors for the numbers to mean something.

1. **Add the URL** Create a service in Logdash and paste the address of your health endpoint, or your homepage if the site is static. The first check runs straight away, so a wrong path shows up in seconds rather than during an incident.
2. **Pick the interval** Every 5 minutes on the free plan, every minute on Builder, every 15 seconds on Pro. Each check stores the status code and response time, so you get a latency chart from one place to set against your RUM data.
3. **Break it on purpose** Connect a Telegram channel, then stop the app or make the endpoint return 503\. An alert you never tested is an alert you cannot trust. On the next check the monitor flips to down and a Telegram alert lands on your phone with the monitor name, the status code and the error.

### What is synthetic monitoring? 

Monitoring that sends scripted requests to your app on a schedule, either single HTTP checks or a headless browser running a script, and alerts you when the result is wrong. It works with zero traffic.

### Synthetic monitoring vs real user monitoring: which should I set up first? 

Synthetic. It catches a full outage within one check interval even when nobody is on the site, and it takes one URL to set up. RUM needs a script in every page and enough visitors before its numbers mean anything.

### Synthetic monitoring vs RUM: can one replace the other? 

No. Synthetic sees one request from one place and misses slow pages for real users. RUM sees real visits and goes silent when the site is fully down. Logdash is synthetic only, so pair it with a RUM tool if field data matters to you.

### Synthetic monitoring vs APM: what is the difference? 

APM runs inside your server and traces where each request spends its time. Synthetic monitoring runs outside and checks whether the request works at all. APM explains a slow endpoint; synthetic catches the dead one APM cannot report from.

## Keep reading

[All uptime monitoring explainers](https://logdash.io/learn): Fourteen uptime questions, each answered in one sentence, then the math or the command behind it.

[What is heartbeat monitoring](https://logdash.io/learn/what-is-heartbeat-monitoring): Heartbeat monitoring turns the usual uptime check around: your job or worker calls a monitor URL every time it finishes a unit of work, and the monitor alerts you when those calls stop arriving.

[What is cron monitoring](https://logdash.io/learn/what-is-cron-monitoring): Cron monitoring tells you when a scheduled job did not run or did not succeed, by having each successful run leave a signal and alerting you when the expected signal is missing.

[How to check if a website is down](https://logdash.io/learn/how-to-check-if-a-website-is-down): Load the site from a second network, such as your phone on mobile data, and run curl against it from a terminal: if both fail it is down for everyone, and if only your connection fails the problem sits between you and the site.

[Uptime monitoring](https://logdash.io/features/monitoring): HTTP checks as often as every 15 seconds. When one fails, Telegram tells you before your users do.