Building Multi-Region Synthetic Monitoring with Grafana Open Source (For Free)

Why synthetic monitoring doesn’t need to be expensive

Most discussions around synthetic monitoring immediately lead to SaaS tools:
Datadog, Dynatrace, New Relic — all powerful, all expensive, all usage-based.

But here’s the uncomfortable truth:

Synthetic monitoring is not expensive because it’s hard.
It’s expensive because it’s usually outsourced.

In this post, I’ll show how to build private, multi-region synthetic monitoring using Grafana Open Source tools, with:

Real browser tests
Multiple geographic vantage points
No SaaS
No trials
No money

This is not a “cheap alternative” — it’s an ownership-first design, the kind real SRE teams use.

The problem with traditional uptime monitoring

Classic monitoring asks:

“Is the server responding?”

Users ask:

“Can I actually use the site?”

These are not the same question.

A website can:

Return HTTP 200
Have healthy servers
Show green dashboards

…and still be unusable because:

JavaScript fails
Navigation breaks
Pages never render
Only one region is affected

This gap is exactly where synthetic monitoring lives.

What we’re going to build

We’ll build a system that answers one question:

“Can a real user complete a real journey from different parts of the world?”

The stack (100% open source)

k6 OSS (browser mode) → runs real Chromium journeys
Grafana OSS → visualisation (optional but powerful)
Your own runners → define the regions
Cost → ₹0 / $0 (excluding optional VPS later)

No SaaS dashboards.
No usage limits.
No lock-in.

Key idea: regions are where you run, not a feature

This is the most important concept to understand.

k6 Open Source does not “have regions”.
Regions come from where the test is executed.

If you run the same test from:

London
Frankfurt
Mumbai

You have multi-region monitoring — regardless of the tool.

This is how the internet actually works.

Step 1: Write a real browser synthetic journey

Instead of pinging an endpoint, we test a user journey.

Example journey:

Open a finance hub → click an article → wait like a real user

k6 browser script

import { browser } from 'k6/browser';
import { check } from 'k6';

export const options = {
  scenarios: {
    journey: {
      executor: 'shared-iterations',
      vus: 1,
      iterations: 1,
      options: {
        browser: { type: 'chromium' },
      },
    },
  },
  tags: {
    job: 'platformsignals_browser_synthetic',
    instance: __ENV.INSTANCE || 'local',
  },
};

export default async function () {
  const page = await browser.newPage();

  await page.goto(
    'https://www.platformsignals.dev/',
    { waitUntil: 'domcontentloaded' }
  );

  const title = await page.title();
  check(title, {
    'homepage loaded': (t) =>
      t.toLowerCase().includes('platform') ||
      t.toLowerCase().includes('signals'),
  });

  const links = await page.$$eval('a', (as) =>
    as
      .map((a) => a.href)
      .filter((h) => h && h.startsWith('https://www.platformsignals.dev'))
      .slice(0, 3)
  );

  for (const link of links) {
    await page.goto(link, { waitUntil: 'domcontentloaded' });
    await page.waitForTimeout(2000); // simulate reading time
  }

  await page.close();
}

This test doesn’t care about servers.
It cares about experience.

Step 2: Make it “multi-region” (without paying anyone)

Here’s the trick that makes everything click.

You run the same script, but label where it runs:

INSTANCE=uk-london k6 run browser-platformsignals.js
INSTANCE=eu-frankfurt k6 run browser-platformsignals.js
INSTANCE=ap-mumbai k6 run browser-platformsignals.js

What does this do?

INSTANCE is just a label
The machine location is the region
The script stays identical everywhere

Synthetic monitoring isn’t global because the tool is global.
It’s global because the runners are.

Step 3: Where do these “regions” come from?

Here’s how you do this without spending money.

Option 1: GitHub Actions (private repo)

Free minutes (limited, but enough)
Good for learning, blogs, demos
Not perfect geo accuracy — but acceptable early on

Option 2: Free / cheap VMs (still near-zero cost)

Oracle Cloud Free Tier (Asia)
One small VPS in EU or UK (~$4/month)
Run k6 via cron

Even 2 regions is enough to demonstrate global thinking.

Step 4: Visualising with Grafana Open Source

Once you emit metrics (optional step), Grafana OSS lets you answer real questions:

Is Frankfurt slower than London?
Are failures regional or global?
Is latency trending up over time?

The key benefit isn’t pretty charts — it’s context.

A single failure is noise.
The same journey failing in two regions is a signal.

Alerting philosophy (this matters more than tooling)

The biggest mistake teams make:

Alerting on every synthetic failure.

With browser tests, that’s a recipe for noise.

What not to alert on

One failed run
One slow page
One region blip

What to alert on

Same journey failing across regions
Sustained failure over time
Error budget burn (if you define SLOs)

Synthetic monitoring is a decision aid, not a pager generator.

OSS vs SaaS: the honest comparison

Aspect	Grafana OSS approach	SaaS synthetics
Cost	Free / predictable	Usage-based
Privacy	Full control	Vendor-managed
Regions	You decide	Vendor decides
Learning value	Very high	Low
Setup effort	Higher	Lower

This approach isn’t for everyone — but if you care about ownership, it’s unmatched.

When this approach makes sense

Use this if:

You want private monitoring
You want to learn SRE fundamentals
You want multi-region insight without lock-in
You want to understand why systems fail

Don’t use it if:

You want instant dashboards with no setup
You don’t want to manage runners at all

The real takeaway

Synthetic monitoring is not about tools.
It’s about where you stand and what you observe.

If you control the journey and the vantage point,
you don’t need to pay to understand reliability.

Grafana Open Source gives you the building blocks.
The architecture — and the insight — are up to you.