Vercel and Netlify are the go-to platforms for shipping modern frontend apps - instant previews, global CDNs, Git-triggered deploys, zero-ops hosting. They make deployment frictionless. But there's a gap they don't fill: knowing when your site or API is actually down.
This tutorial shows you how to close that gap with Vigilmon, a multi-region uptime monitor with smart consensus alerting. Free tier, no credit card required.
Why Vercel and Netlify Analytics Won't Tell You When You're Down
Both platforms give you traffic dashboards, function invocation counts, build logs, and deployment history. What they don't give you is active uptime monitoring.
Here's why that matters:
- Traffic dashboards are passive. They report on requests that came in. If nobody's hitting your site during a 3 AM outage, the graph just looks quiet - not broken.
- Build success does not equal runtime success. Your deploy can go green while a missing environment variable silently breaks your app at runtime.
- Vercel edge functions can partially fail. Vercel runs your app across dozens of edge regions. An outage in iad1 (US East) won't always show up as a global failure - users in that region just get errors while your dashboard looks fine.
- Netlify's CDN node issues are invisible to you. Same story: a CDN PoP problem means a subset of users experience 5xx errors you'll never hear about unless someone tweets at you.
You need an external observer that checks your site from outside your infrastructure, from multiple locations, on a regular schedule. That's exactly what Vigilmon does.
What Is Vigilmon?
Vigilmon is an uptime monitoring service that checks your URLs from multiple geographic regions simultaneously. The key differentiator is consensus alerting: Vigilmon only fires an alert when 2 or more regions confirm that something is wrong. This eliminates false positives caused by transient network blips or single-node weirdness.
Features at a glance:
- Multi-region checks (US, EU, Asia-Pacific, and more)
- Consensus alerting - no alert spam from single-region noise
- Email and webhook notifications
- Public status pages you can share with users
- Free tier: 5 monitors, no credit card required
Setting Up Vigilmon: Step by Step
Step 1: Create an Account
Go to vigilmon.online and sign up. The free tier gives you 5 monitors with no credit card. That's enough to cover your main site, a couple of API routes, and a status page.
Step 2: Add Your First Monitor
After logging in, click "Add Monitor". Fill in:
- URL: Your Vercel or Netlify production URL, e.g. https://yourapp.vercel.app or https://yourapp.netlify.app (or your custom domain if you've connected one).
- Name: Something descriptive like My Next.js App - Production.
- Check interval: 1 minute is standard for production apps.
- Check type: HTTP(S) - confirms the server returns a 2xx response.
Hit Save. Vigilmon immediately starts polling your URL from all active regions.
Tip for Next.js on Vercel: Add a lightweight /api/health route that returns { status: "ok" } and monitor that endpoint instead of (or in addition to) your homepage. It's faster to respond and isolates infrastructure health from rendering issues.
`js
// pages/api/health.js (Next.js Pages Router)
export default function handler(req, res) {
res.status(200).json({ status: 'ok', timestamp: Date.now() });
}
// app/api/health/route.js (Next.js App Router)
export async function GET() {
return Response.json({ status: 'ok', timestamp: Date.now() });
}
`
For Gatsby or Astro on Netlify, monitor your homepage or a dedicated /_health page rendered as a static route. Static sites can't run server-side health endpoints, but checking the homepage serves the same purpose - it confirms the CDN is serving your content correctly.
Step 3: Understanding Multi-Region Consensus (Why It Matters for Edge Apps)
Vercel's Edge Network runs your serverless functions close to users - great for latency, tricky for monitoring. A failure in one edge region won't take down your whole app, but it will affect users in that region.
Most single-probe monitoring tools check from one location. If that location's probe happens to route to a healthy region, it won't catch a regional failure. Worse, if a single probe hits a brief DNS or BGP hiccup, you get a false alarm at 3 AM.
Vigilmon solves both problems with consensus alerting:
- It polls your URL from multiple regions every check interval.
- If one region sees a failure, it logs it but holds the alert.
- If two or more regions confirm the failure within the same window, it fires the alert.
This gives you:
- Fewer false positives (transient single-region noise is ignored)
- Genuine regional outage detection (a multi-region failure pattern triggers fast)
- Better signal for edge-deployed apps where "partially down" is a real state
Step 4: Set Up Alerts
In your monitor settings, go to Notifications.
Email alerts are on by default. Make sure the address is one you actively monitor - or better, a team distribution list.
Webhook alerts let you pipe notifications into Slack, Discord, PagerDuty, or any HTTP endpoint. Here's what the Vigilmon webhook payload looks like:
json
{
"event": "monitor.down",
"monitor": {
"id": "mon_abc123",
"name": "My Next.js App - Production",
"url": "https://yourapp.vercel.app/api/health"
},
"regions_failing": ["us-east-1", "eu-west-1"],
"first_detected_at": "2025-03-14T03:22:11Z",
"status_code": 503
}
To forward this to a Slack channel, create a Slack incoming webhook and point Vigilmon at it. Vigilmon's payload is plain JSON - your Slack app can transform it with a message template, or you can use a small Vercel function as middleware:
`js
// pages/api/vigilmon-to-slack.js
export default async function handler(req, res) {
if (req.method !== 'POST') return res.status(405).end();
const { monitor, event, regions_failing } = req.body;
const emoji = event === 'monitor.down' ? '🔴' : ':large_green_circle:';
const text =
${emoji} ** is \n +
URL: \n +
Regions affected: ;
await fetch(process.env.SLACK_WEBHOOK_URL, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ text }),
});
res.status(200).json({ ok: true });
}
`
Deploy that to Vercel, set SLACK_WEBHOOK_URL in your environment variables, and point Vigilmon's webhook at https://yourapp.vercel.app/api/vigilmon-to-slack.
Step 5: Monitoring API Routes on Vercel
Vercel projects often include API routes alongside the frontend. These have distinct URL patterns depending on your router:
| Project type | API route pattern |
|---|---|
| Next.js Pages Router | /api/ |
| Next.js App Router | /api/ (same) |
| Vercel Serverless Functions | /api/ |
| Edge Functions | Same paths, runs at the edge |
Add a separate monitor for each critical API route. Don't bundle everything into one monitor - a failure in your /api/checkout endpoint is a different severity than your homepage being slow.
Example monitors to set up for a typical Next.js e-commerce app:
https://yourstore.vercel.app ? "Homepage"
https://yourstore.vercel.app/api/health ? "API Health"
https://yourstore.vercel.app/api/products ? "Products API"
https://yourstore.vercel.app/api/checkout ? "Checkout API" (highest priority)
For API routes that require authentication, set up a dedicated test endpoint that doesn't need auth headers but performs a meaningful internal check:
js
// app/api/health/deep/route.js
export async function GET() {
try {
await db.query('SELECT 1');
return Response.json({ status: 'ok', db: 'connected' });
} catch (err) {
return Response.json(
{ status: 'error', db: 'disconnected', message: err.message },
{ status: 503 }
);
}
}
Vigilmon treats any non-2xx response as a failure, so returning 503 when your DB is down will correctly trigger an alert.
Step 6: Create a Public Status Page
Status pages build trust. Users who can check status.yourapp.com during an incident are less likely to flood your support inbox.
In Vigilmon, go to Status Pages and click Create Page. You can:
- Give the page a name and custom slug (e.g. yourapp-status)
- Add monitors to it - pick the ones you want to be public
- Optionally add your own logo and description
Vigilmon hosts the page at a public URL. Share it in your app footer, your README, and your error pages. If you want a custom domain like status.yourapp.com, point a CNAME record at Vigilmon's hosted page.
Your Netlify or Vercel error page can even link to it:
`html
Experiencing issues? Check our status page for real-time updates.
`
Real-World Example: Catching a Silent Vercel Edge Failure
Here's a scenario that illustrates why this setup matters.
A Next.js app deployed on Vercel had a working homepage and passing CI. At 2:47 AM UTC, a configuration change to an edge middleware rule caused requests from EU regions to return 500 errors. US users were fine. The Vercel dashboard showed green. Analytics showed a dip in EU traffic, but the team didn't notice until a user in Germany emailed in the morning.
With Vigilmon:
- At 2:48 AM, the EU probe records a 500 from /api/health.
- At 2:49 AM, the second EU probe confirms. Consensus threshold crossed.
- Alert fires to the on-call engineer's Slack at 2:49 AM.
- Middleware rule reverted by 2:55 AM. Total user-visible downtime: ~8 minutes.
Without Vigilmon: 6+ hours of silent EU failures.
Quick-Start Checklist
- [ ] Sign up at vigilmon.online (free, no CC)
- [ ] Add a monitor for your Vercel/Netlify production URL
- [ ] Add a /api/health endpoint to your Next.js app
- [ ] Add separate monitors for critical API routes
- [ ] Configure email + webhook (Slack/Discord) notifications
- [ ] Create a public status page and link it from your app
- [ ] Set check interval to 1 minute for production monitors
Wrapping Up
Vercel and Netlify abstract away most deployment complexity, but they can't abstract away the reality that distributed systems fail in distributed ways. Edge deployments add a new class of partial failures that are invisible to platform dashboards but very visible to your users.
Vigilmon's multi-region consensus approach is a natural fit for edge-deployed apps: it's designed to catch the exact pattern of "some regions are failing" that makes Vercel edge outages hard to detect with traditional single-probe tools.
Five monitors on the free tier is enough to cover the critical paths of most side projects and small production apps. When you're ready to scale up, paid plans lift the monitor count and add shorter check intervals.
Start monitoring for free at vigilmon.online - takes less than 5 minutes to set up your first monitor.
Top comments (0)