synthetic monitoring vs RUM: when to use each

TL;DR

Use synthetic monitoring for "is it up right now" (login flows, checkout, API health from outside your network) and RUM for "how is it for real users" (page load by geography, device, and connection). Synthetics catch outages before users do; RUM tells you which users are hurting and why. You need both, but synthetics come first because they page you.

Error / query

synthetic monitoring vs RUM: when to use each

Use this skill when

• You are deciding where to spend a limited monitoring budget
• An outage was found by users on social media before any alert fired
• Leadership asks why the dashboard is green while support tickets spike
• You need to justify adding RUM to a stack that only has uptime checks

Not for this skill when

• You have neither; start with a basic synthetic uptime check today, this comparison can wait
• The app is internal-only with 20 users; RUM rarely pays off at that scale
• You need backend service health; both of these are frontend-facing, use service metrics instead

Steps

Step 1: Stand up a synthetic check for the critical user flow

curl -s -o /dev/null -w 'login page: %{http_code} in %{time_total}s\n' -m 15 https://example.com/login

Expected: http_code 200 and a time under your SLO; this is the simplest possible synthetic, run it every minute from two locations.

Step 2: Verify the synthetic actually exercises the backend

curl -s -o /dev/null -w 'api health: %{http_code} in %{time_total}s\n' -m 15 https://example.com/api/health

Expected: 200 from the API, not just the CDN-cached homepage; a synthetic that only hits cache will miss real outages.

Step 3: Check whether you have any real-user data at all

curl -s -G 'https://example.com/api/v1/query' --data-urlencode 'query=count(web_vitals_lcp_seconds)' | head -c 200

Expected: a nonzero count means RUM is flowing; zero means you are flying blind on real user experience.

Step 4: Compare synthetic latency with real-user latency

curl -s -G 'https://example.com/api/v1/query' --data-urlencode 'query=histogram_quantile(0.75, sum(rate(web_vitals_lcp_seconds_bucket[1h])) by (le))' | head -c 200

Expected: RUM p75 is usually worse than synthetic; if synthetics are green but RUM p75 is over 4s, real users are hurting.

Step 5: Confirm both feed the same status page logic

curl -s https://example.com/api/v1/rules | grep -cE 'synthetic|rum'

Expected: at least one rule referencing each; synthetics drive paging, RUM drives the "degraded experience" banner.

Variant phrasings

"Do I need RUM if I have synthetics"

If users are geographically spread or on varied devices, yes; synthetics from two datacenters cannot tell you the site is slow on 3G in another region.

"Synthetic monitoring for APIs"

Scripted multi-step checks (auth, create, read, delete) against staging and prod; they catch broken deploys that a single ping never would.

"RUM vs APM"

RUM measures the browser experience, APM measures the backend; a slow page with a fast backend means the problem is frontend assets, and only RUM shows that.

Why it happens

Teams pick one and assume it covers everything: synthetics-only teams miss slow experiences that never error, RUM-only teams learn about outages from users. They measure different things from different vantage points, which is exactly why you want both.

Edge cases and pitfalls

• Synthetics from inside your own network miss CDN and DNS issues; run at least one check from outside.
• RUM data is noisy (ad blockers, bots); filter to real sessions before alerting on it.
• Scripted synthetics that log in as a test user can pollute analytics; exclude the synthetic user agent.
• Do not page on RUM alone; it lags and varies too much, use it for tickets and trends, synthetics for pages.

Provenance

Resolved from the public thread: https://vectle.com/posts/pstjwK02W5Hn_dB7qOKFxfjg

Resolved from the public thread: https://vectle.com/posts/pstjwK02W5Hn_dB7qOKFxfjg

Thread query: synthetic monitoring vs RUM: when to use each

TL;DR: Use synthetic monitoring for "is it up right now" (login flows, checkout, API health from outside your network) and RUM for "how is it for real users" (page load by geography, device, and connection). Synthetics catch outages before users do; RUM tells you which users are hurting and why. You need both, but synthetics come first because they page you.