Skip to content

Open-source status page, incident response and uptime monitoring

Add foundational guides on incident management and monitoring (#2147)

Maximilian Kaske83078119202e
diff --git a/apps/web/src/content/pages/guides/sla-vs-slo-vs-sli.mdx b/apps/web/src/content/pages/guides/sla-vs-slo-vs-sli.mdx
index 07140ccb1..afc374763 100644
--- a/apps/web/src/content/pages/guides/sla-vs-slo-vs-sli.mdx
+++ b/apps/web/src/content/pages/guides/sla-vs-slo-vs-sli.mdx
@@ -3,7 +3,7 @@ title: "SLA vs SLO vs SLI Explained"
description: "Learn the critical differences between SLAs, SLOs, and SLIs. Understand how to measure service reliability, set internal targets, and make customer promises without over-committing or under-delivering."
author: "openstatus"
publishedAt: "2026-02-09"
-category: "education"
+category: "fundamentals"
faq:
- question: "What's the difference between SLI, SLO, and SLA?"
answer: "An SLI is a specific metric you measure (like API response time). An SLO is your internal target for that metric (stricter than customer promises). An SLA is your public promise to customers with consequences if you fail. They stack: SLI → SLO → SLA."
@@ -17,8 +17,6 @@ faq:
answer: "No. Early-stage startups should skip SLAs entirely until they have the infrastructure to measure and maintain them. Focus on tracking 2-3 SLIs, being transparent about uptime, and communicating clearly during incidents. Formalize SLAs when enterprise customers start requesting them."
---
-# SLA vs SLO vs SLI Explained
-
Everyone throws these acronyms around at architecture reviews and planning meetings, but most teams confuse them. You'll hear "our SLA is 99.9%" when they mean SLO. Or "we need better SLIs" when they haven't defined what they're actually measuring.
Getting this wrong has real consequences. Either you over-promise to customers and violate agreements you can't afford to break, or you set vague internal targets that don't guide any actual engineering decisions.
diff --git a/apps/web/src/content/pages/guides/what-is-a-status-page.mdx b/apps/web/src/content/pages/guides/what-is-a-status-page.mdx
new file mode 100644
index 000000000..690868d92
--- /dev/null
+++ b/apps/web/src/content/pages/guides/what-is-a-status-page.mdx
@@ -0,0 +1,150 @@
+---
+title: "What Is a Status Page?"
+description: "A status page is a public web page that communicates the real-time health of your service - uptime, ongoing incidents, scheduled maintenance, and historical reliability. Here's what they include, why they matter, and how to build one that actually helps users."
+author: "openstatus"
+publishedAt: "2026-05-05"
+category: "fundamentals"
+faq:
+ - question: "What is a status page?"
+ answer: "A status page is a public-facing web page that displays the real-time operational health of a service. It shows current uptime, active incidents, scheduled maintenance, and historical reliability metrics. The point is to give users a single, trustworthy place to check whether a problem is on your end or theirs."
+ - question: "Why do companies need a status page?"
+ answer: "Without a status page, every outage floods your support inbox with the same question: 'is it down?' A status page deflects that load, builds trust by being transparent during incidents, and signals operational maturity to enterprise buyers who often require one before signing a contract."
+ - question: "What's the difference between a public and private status page?"
+ answer: "A public status page is visible to anyone and shows curated, user-facing reliability data. A private status page is gated behind authentication and shows real-time operational metrics to internal teams or specific customers - typically more granular and used for SLO tracking, not customer communication."
+ - question: "What should a status page include?"
+ answer: "At minimum: current component statuses (API, dashboard, auth, etc.), active incidents with timestamps and updates, scheduled maintenance windows, and historical uptime for the last 30-90 days. Optional but valuable: subscription options (email, SMS, Slack, RSS), incident postmortems, and per-region status."
+ - question: "Should my status page be on a separate domain?"
+ answer: "Yes. Host it on a separate domain or subdomain (e.g., status.yourcompany.com) on independent infrastructure. If your main service is down and your status page is on the same servers, users see nothing - exactly when they need information most."
+ - question: "How often should I update a status page during an incident?"
+ answer: "Every 15-30 minutes during an active incident, even if there's nothing new to report. 'Still investigating, next update at 14:30' is more useful than silence. Silence makes users assume you've abandoned them."
+ - question: "Do small companies need a status page?"
+ answer: "If you have paying customers, yes. It's not about scale - it's about trust. A simple status page with uptime history and an incident feed signals you take reliability seriously. It takes less than an hour to set up and pays for itself the first time something breaks."
+ - question: "What's the difference between a status page and a monitoring tool?"
+ answer: "A monitoring tool checks whether your service is up and alerts your team. A status page communicates that information to users. They're connected - monitoring data often drives status page updates - but they serve different audiences. Monitoring is for engineers; status pages are for customers."
+---
+
+When something breaks in production, users need to know if the problem is on your end or theirs. Without a single source of truth, they find out by filing duplicate support tickets, posting on social media, or assuming your whole company is down.
+
+That single source of truth is the status page. It exists to deflect support load during outages, build trust through honest communication, and signal to enterprise buyers that you take reliability seriously.
+
+---
+
+## What a Status Page Actually Shows
+
+A useful status page has four things:
+
+### 1. Component Status
+
+A list of the major parts of your service - API, dashboard, authentication, billing, integrations - each with a current state (operational, degraded, partial outage, major outage).
+
+This is the headline. Users scan it in two seconds to answer: "is the part I care about broken?"
+
+### 2. Active Incidents
+
+When something is wrong, you post an incident with a timestamp, affected components, severity, and a running timeline of updates.
+
+The format matters. Each update should answer: what happened, what we know, what we're doing, when we'll update next. "Investigating" with no follow-up for two hours is worse than no status page at all.
+
+### 3. Scheduled Maintenance
+
+Planned downtime, announced in advance with a window, affected components, and expected impact. This is how you preserve trust during necessary disruptions - users tolerate maintenance they knew about.
+
+### 4. Historical Uptime
+
+A rolling view of the last 30, 60, or 90 days showing uptime percentages and past incidents. This is your reliability proof. Enterprise buyers will scroll through it before signing a contract.
+
+---
+
+## Why Companies Use Status Pages
+
+### Deflect Support Load
+
+Every outage generates a wave of identical support tickets: "is it down for everyone?" A public status page answers that question without a human in the loop. Big incidents that would have taken a team hours to triage become a single status page update.
+
+### Build Trust Through Transparency
+
+Counterintuitively, admitting failures publicly builds trust. Companies that hide outages get caught - users notice, screenshot, and post on social. Companies that own incidents publicly with clear updates and honest postmortems come out stronger. Reliability isn't never failing. It's failing well.
+
+### Meet Enterprise Requirements
+
+Enterprise buyers often require a public status page before signing. It's table stakes for B2B SaaS above a certain deal size. No status page, no contract.
+
+### Coordinate Internal Response
+
+A status page is also a forcing function for incident response. The act of writing a public update clarifies what you actually know, what you're doing, and what's still uncertain. It's a discipline as much as a communication channel.
+
+---
+
+## Public vs Private Status Pages
+
+**Public** pages are for customers. They're curated, lag slightly behind real-time, and focus on user-impacting events. The audience is non-technical. Updates are written in plain language.
+
+**Private** pages are for internal teams or specific partners. They're real-time, granular, and often include metrics that would confuse public users (per-region latency, error budget burn rate, SLO compliance). The audience is engineers and operations.
+
+Most mature SaaS companies run both. Public for trust, private for operations. See our guide on [public vs private status pages](/guides/public-vs-private-status-pages) for the deeper tradeoffs.
+
+---
+
+## What Makes a Good Status Page
+
+### Hosted Independently
+
+Put it on a separate domain (status.yourcompany.com) on infrastructure that doesn't share fate with your main service. If your status page goes down with your service, it's worse than not having one - users assume the whole company is offline.
+
+### Honest in Real Time
+
+A status page that shows "all systems operational" during an obvious outage destroys trust faster than no status page at all. Better to say nothing than to lie. Better to say "investigating reports of issues" than to wait for full diagnosis.
+
+### Subscribable
+
+Users should be able to subscribe to updates via email, SMS, Slack, RSS, or webhook. Polling the page is not a workflow. The whole point is that updates push to users.
+
+### Searchable Historical Record
+
+Past incidents stay accessible. Postmortems get linked from incident pages. Uptime metrics are computable and visible. This is how the status page doubles as a long-term reliability signal.
+
+---
+
+## Common Mistakes
+
+**Only updating once an incident is resolved.** Users want updates *during* the incident. Resolved-after-the-fact is documentation, not communication.
+
+**Vague status definitions.** What's the difference between "degraded" and "partial outage" on your page? If your team doesn't know, neither do your users. Define them and stick to it.
+
+**Painting things green.** A status page that's always 100% green when users are experiencing problems isn't a status page - it's a marketing brochure. Tune your monitoring to actually surface user impact.
+
+**No subscription options.** Forcing users to refresh manually means they don't get updates. They get frustrated and tweet at you instead.
+
+---
+
+## How Status Pages Connect to Monitoring
+
+A status page is a communication layer. The data behind it comes from your [uptime monitoring](/guides/what-is-uptime-monitoring) and [synthetic monitoring](/guides/what-is-synthetic-monitoring) systems.
+
+The pipeline:
+1. Monitors detect a problem
+2. Alerts wake up on-call engineers
+3. Engineers triage and update the status page
+4. Users see the update and stop filing duplicate tickets
+
+Some teams automate step 3 for low-severity events. Most keep a human in the loop for anything customer-visible - automated status updates that fire on flaky monitors create more noise than they prevent.
+
+---
+
+## The Bottom Line
+
+A status page is the simplest, highest-leverage trust-building tool you have during incidents. It deflects support load, signals maturity, and forces you to communicate clearly when things break.
+
+If you don't have one, you're either too small to need one (rare) or losing trust during every outage without realizing it (common).
+
+---
+
+**OpenStatus is an open-source status page and monitoring platform.** Set up a public status page, configure monitors, and start communicating reliably during incidents - all from one place.
+
+<ButtonLink href="https://app.openstatus.dev">Try openstatus free</ButtonLink>
+
+---
+
+Start free. No credit card required. Set up your first status page in under 5 minutes.
+
+---
diff --git a/apps/web/src/content/pages/guides/what-is-incident-management.mdx b/apps/web/src/content/pages/guides/what-is-incident-management.mdx
new file mode 100644
index 000000000..5a3b7817f
--- /dev/null
+++ b/apps/web/src/content/pages/guides/what-is-incident-management.mdx
@@ -0,0 +1,192 @@
+---
+title: "What Is Incident Management?"
+description: "Incident management is the process teams use to detect, respond to, resolve, and learn from service disruptions. Here's the lifecycle, the roles, the severity model, and what separates teams that handle incidents well from those who don't."
+author: "openstatus"
+publishedAt: "2026-05-08"
+category: "fundamentals"
+faq:
+ - question: "What is incident management?"
+ answer: "Incident management is the process a team uses to detect, respond to, resolve, and learn from unplanned service disruptions. It covers the technical work of fixing the problem, the communication work of keeping customers informed, and the organizational work of running a postmortem so the same problem doesn't recur."
+ - question: "What are the stages of an incident lifecycle?"
+ answer: "Detection (something is wrong), declaration (someone calls it an incident), response (assemble a team and start mitigating), communication (update customers via the status page), resolution (the immediate problem is fixed), and postmortem (learn what happened and prevent recurrence). Each stage has a different cadence and a different audience."
+ - question: "What's an incident commander?"
+ answer: "The incident commander is the single person responsible for coordinating the response - making decisions, assigning tasks, and keeping the team focused. They are not necessarily the most technical person on the call. Their job is leadership during the incident: who's doing what, what we know, when we'll update customers, when to escalate."
+ - question: "How do you define incident severity?"
+ answer: "Most teams use a 4-tier scale: SEV1 (critical, customer-facing, all hands), SEV2 (major impact, urgent), SEV3 (partial impact, business hours), SEV4 (minor, planned work). The exact thresholds depend on your product, but the key is having clear criteria so the team doesn't argue about severity in the middle of an outage."
+ - question: "What's the difference between an incident and an outage?"
+ answer: "An outage is one type of incident - your service is fully unreachable. An incident is any unplanned disruption: outages, degraded performance, data correctness issues, security events, third-party failures. All outages are incidents; not all incidents are outages."
+ - question: "What goes in an incident postmortem?"
+ answer: "A clear timeline of what happened, root cause analysis, customer impact (how many users, how long, what they experienced), what went well, what didn't, and action items with owners and due dates. The point is to learn - blameless framing, focus on systems and processes rather than individuals."
+ - question: "How quickly should you update customers during an incident?"
+ answer: "Initial acknowledgment within 5-15 minutes of detection. Updates every 15-30 minutes during active incidents, even if there's nothing new to report - silence is worse than 'still investigating, next update at 14:30'. Resolution message when the immediate problem is fixed. Follow-up postmortem within a week."
+ - question: "What's MTTR and why does it matter?"
+ answer: "MTTR (Mean Time To Recovery) is the average time from incident detection to resolution. It's the headline metric for incident response maturity. Lower MTTR means faster recovery, less customer impact, and usually better tooling and process. See our guide on MTTR for the full breakdown."
+ - question: "What's a blameless postmortem?"
+ answer: "A postmortem that focuses on systems, processes, and contributing factors rather than individual mistakes. The premise: people don't show up wanting to cause incidents - if a system allowed a human error to cause customer impact, the system is the problem. Blameless framing produces honest postmortems; blame-heavy framing produces defensive ones."
+---
+
+Every team deals with unplanned service disruptions. The difference between teams that handle them well and teams that don't comes down to whether they have an actual process - or whether each outage is improvised from scratch.
+
+That process is incident management. It runs three workstreams in parallel during every incident: fixing the technical problem, communicating with affected users, and learning from what happened so the same thing doesn't recur. Teams that neglect any of the three pay for it later.
+
+---
+
+## The Incident Lifecycle
+
+A well-run incident moves through six stages:
+
+### 1. Detection
+
+Something is wrong. The signal might come from automated monitoring, a customer support ticket, an internal user, or social media. The faster you detect, the lower the customer impact - this is what [synthetic monitoring](/guides/what-is-synthetic-monitoring) and [uptime monitoring](/guides/what-is-uptime-monitoring) buy you.
+
+### 2. Declaration
+
+Someone formally calls it an incident. This matters because declaration triggers process - paging on-call, opening a war room channel, posting an initial [status page](/guides/what-is-a-status-page) update. Without declaration, you have a vague "something seems off" feeling that nobody owns.
+
+Lower the bar to declare. False positives are cheap. Real incidents that nobody declared for an hour are expensive.
+
+### 3. Response
+
+The team assembles and starts mitigating. An incident commander takes coordination duty. Engineers investigate, propose fixes, and act. Communication lead drafts status page updates.
+
+The goal in this phase is mitigation, not root cause. Restore service first. Understand why later.
+
+### 4. Communication
+
+Updates flow to customers through the status page and any subscribed channels (email, Slack, SMS). Cadence matters: initial acknowledgment fast, updates every 15-30 minutes during the incident, resolution message when fixed.
+
+Communication is not separate from response - it's part of it. Customer trust is being burned in real time during an incident, and communication is how you slow the burn.
+
+### 5. Resolution
+
+The immediate problem is mitigated. Service is restored, even if the underlying cause isn't fully understood. The status page goes back to operational. The incident commander stands down the response team.
+
+This is not the end - it's the start of the next phase.
+
+### 6. Postmortem
+
+Within a week, write up what happened. Timeline, root cause, customer impact, contributing factors, action items. Share it broadly inside the company. Consider sharing externally if customers were significantly affected - public postmortems are [underrated marketing](/guides/public-postmortem-underrated-marketing).
+
+The point is to learn. If your postmortems aren't producing action items that actually get done, you're doing them wrong.
+
+---
+
+## Roles During an Incident
+
+Small teams may have one person filling multiple roles. Larger teams split them explicitly.
+
+### Incident Commander (IC)
+
+The single person responsible for coordinating the response. Makes decisions, assigns tasks, decides when to escalate, calls the resolution.
+
+The IC is not necessarily the most senior or most technical person. Their job is leadership during the incident: who's doing what, what we know, what we don't, when we'll communicate next. A good IC keeps the response organized when everyone else is in heads-down debugging mode.
+
+### Communications Lead
+
+Drafts and posts status page updates. Coordinates with customer support and PR. Keeps internal stakeholders informed.
+
+Critical role because the technical responders are deep in problem-solving and shouldn't context-switch to draft customer-facing copy every 20 minutes.
+
+### Subject Matter Experts (SMEs)
+
+Engineers who actually fix the problem. They report to the IC. They focus on technical work. They don't run the incident - they execute under the IC's coordination.
+
+### Scribe (optional)
+
+Captures the timeline as the incident unfolds. Hugely valuable for the postmortem because human memory is unreliable two hours later. Often the IC takes notes themselves on smaller incidents.
+
+---
+
+## Severity Levels
+
+A working severity model:
+
+| Severity | Criteria | Response |
+|----------|---------------------------------------------------------------------------|-----------------------------------|
+| **SEV1** | Full outage or critical data loss affecting many customers | All-hands, page on-call immediately, public status update within 15m |
+| **SEV2** | Major feature broken, significant customer impact, or revenue at risk | Page on-call, public status update within 30m |
+| **SEV3** | Partial impact, workaround exists, no immediate revenue risk | Business hours response, status update if customer-facing |
+| **SEV4** | Minor issue, internal-only, or planned/expected impact | Handle in normal work queue |
+
+The exact thresholds depend on your business. The important thing is that they're defined ahead of time so the team isn't arguing about severity in the middle of an outage.
+
+A common pitfall: severity inflation. If everything is SEV1, nothing is. Be honest. Reserve SEV1 for genuine "drop everything" events.
+
+See our [incident severity matrix](/guides/incident-severity-matrix) for a more detailed framework.
+
+---
+
+## Communication During an Incident
+
+The cadence:
+
+- **Initial acknowledgment** within 5-15 minutes of detection: "We're investigating reports of issues affecting X. Next update at HH:MM."
+- **Status updates** every 15-30 minutes: what we know, what we're doing, what's next.
+- **Resolution** when the immediate problem is mitigated: "Service is restored. We are continuing to investigate root cause and will publish a postmortem."
+- **Postmortem** within a week: what happened, why, what we're changing.
+
+Silence is the enemy. "Still investigating, next update at 14:30" is more useful than nothing. Users tolerate problems they're being told about; they don't tolerate problems they're being ignored about.
+
+---
+
+## Postmortems
+
+A good postmortem has:
+
+1. **Summary** - one paragraph: what broke, how long, who was affected
+2. **Timeline** - what happened, minute by minute, with timestamps
+3. **Root cause** - the technical and process factors that allowed this to happen
+4. **Impact** - quantified: customers affected, requests failed, revenue lost, SLO budget burned
+5. **What went well** - the response worked X way, the runbook helped, the customer comms were on point
+6. **What didn't** - detection took too long, the runbook was out of date, the on-call rotation was wrong
+7. **Action items** - specific, owned, with due dates
+
+**Blameless framing.** People don't show up wanting to cause incidents. If a system allowed a human mistake to cause customer impact, the system is the actual problem. Postmortems that blame individuals produce defensive responses and dishonest writeups. Postmortems that focus on systems produce real improvements.
+
+---
+
+## Common Mistakes
+
+**No formal declaration.** Engineers debug for an hour before someone says "wait, should we call this an incident?" By then, customers have been on Twitter for 45 minutes.
+
+**Severity inflation.** Everything is SEV1, so on-call burns out and nothing is actually prioritized.
+
+**Fixing root cause during the incident.** Restore service first. The instinct to "really fix it" during an active incident usually extends the outage. Mitigate now, root-cause later.
+
+**Postmortem theater.** Writing the document, filing it, and never doing the action items. If the postmortem doesn't change anything, the incident will recur.
+
+**Blame-heavy postmortems.** Producing defensive engineers, dishonest timelines, and a culture where people hide problems instead of escalating them.
+
+**Communication as an afterthought.** Engineers focus on the fix and forget to update the status page for 90 minutes. Customers fill the void with assumptions, all of them worse than reality.
+
+---
+
+## How Monitoring Fits In
+
+Incident management starts the moment you detect a problem. Detection comes from monitoring - external [uptime](/guides/what-is-uptime-monitoring) and [synthetic](/guides/what-is-synthetic-monitoring) checks for service availability, internal metrics for performance and errors.
+
+Better monitoring shortens detection time. Shorter detection time means lower [MTTR](/guides/what-is-mttr). Lower MTTR means less customer impact per incident.
+
+Then communication happens through your [status page](/guides/what-is-a-status-page), which becomes the single source of truth for customers during the incident.
+
+The pipeline: monitor → detect → declare → respond → communicate → resolve → learn. Every part has to work.
+
+---
+
+## The Bottom Line
+
+Incident management isn't about preventing incidents - they happen to everyone. It's about handling them well when they do. Fast detection, organized response, honest communication, blameless learning.
+
+Teams that get this right preserve customer trust through outages. Teams that don't lose it during the second one.
+
+---
+
+**OpenStatus combines monitoring and status pages so detection and communication live in one place.** Open-source, with on-call alerting and incident management built in.
+
+<ButtonLink href="https://app.openstatus.dev">Try openstatus free</ButtonLink>
+
+---
+
+Start free. No credit card required.
+
+---
diff --git a/apps/web/src/content/pages/guides/what-is-mttr.mdx b/apps/web/src/content/pages/guides/what-is-mttr.mdx
new file mode 100644
index 000000000..8d848e00f
--- /dev/null
+++ b/apps/web/src/content/pages/guides/what-is-mttr.mdx
@@ -0,0 +1,214 @@
+---
+title: "What Is MTTR? (And the Other MTT-Whatevers)"
+description: "MTTR is the average time it takes to recover from an incident. But there are four different MTT- metrics that get confused regularly. Here's what each one actually measures, how to calculate them, and how to actually move the numbers."
+author: "openstatus"
+publishedAt: "2026-05-09"
+category: "fundamentals"
+faq:
+ - question: "What is MTTR?"
+ answer: "MTTR most commonly stands for Mean Time To Recovery (or Mean Time To Resolve) - the average time from when an incident is detected to when service is restored. It's calculated as total downtime across incidents divided by the number of incidents. Lower is better. It's the headline metric for incident response maturity."
+ - question: "What's the difference between MTTR, MTTD, MTTA, and MTTF?"
+ answer: "MTTD (Mean Time To Detect) - time from problem occurring to your team noticing. MTTA (Mean Time To Acknowledge) - time from alert firing to a human acknowledging. MTTR (Mean Time To Recovery) - time from detection to service restored. MTTF (Mean Time To Failure) - average time a system runs before failing. They're stages on a timeline; MTTR is usually the headline number."
+ - question: "How do you calculate MTTR?"
+ answer: "Sum the total downtime across all incidents in a period, then divide by the number of incidents. Example: 3 incidents totaling 90 minutes of downtime = MTTR of 30 minutes. Some teams measure from detection to resolution; others from start of impact to resolution. Be explicit about which definition you use."
+ - question: "What's a good MTTR?"
+ answer: "Depends entirely on your service criticality and severity tier. Rough benchmarks for SaaS: SEV1 incidents, under 30 minutes is excellent, 1-2 hours is typical. SEV2, under 2 hours is good. The trend matters more than the absolute number - a team whose MTTR is dropping quarter over quarter is improving; a team with low MTTR that's flat may just be in a quiet period."
+ - question: "Why is MTTR sometimes a misleading metric?"
+ answer: "MTTR averages can hide outliers. Ten 5-minute incidents and one 8-hour outage average out to about 48 minutes - which looks fine, but the 8-hour outage is what customers remember. Track percentiles (P50, P95, P99) and look at the distribution, not just the mean. Also be wary of teams who 'lower MTTR' by silently downgrading incident severity."
+ - question: "How do you actually lower MTTR?"
+ answer: "Three levers: detection (better monitoring lowers MTTD), response (runbooks, on-call rotations, and clear roles lower MTTA and active response time), and recovery (good rollback tooling, feature flags, and automated mitigations lower the time to actually fix things). Each one shaves minutes off the total."
+ - question: "What does MTTF stand for?"
+ answer: "MTTF is Mean Time To Failure - the average uptime between failures. For SaaS, it's the inverse of how often you have incidents. High MTTF means rare incidents. It's usually a hardware reliability metric originally but applies to software systems too. Less commonly tracked than MTTR because it requires a long history of incident data to be meaningful."
+ - question: "What's the difference between Mean Time To Recovery and Mean Time To Resolve?"
+ answer: "Often used interchangeably, but technically: 'recovery' is when service is back to normal for users, 'resolve' is when the underlying issue is fully fixed (which may include follow-up work after service is restored). Pick one definition for your team and use it consistently. Mixing them produces meaningless trends."
+ - question: "Should we track MTTR per severity level?"
+ answer: "Yes. A 4-hour MTTR for SEV3 incidents is fine. A 4-hour MTTR for SEV1 incidents is a problem. Aggregating across severities hides important information. Most teams report MTTR separately for SEV1, SEV2, and SEV3."
+ - question: "How does MTTR relate to SLOs?"
+ answer: "MTTR feeds directly into your error budget. Every minute of downtime burns budget. A team with MTTR of 4 hours has very different error budget math than one with MTTR of 20 minutes. Improving MTTR effectively lets you take more deployment risk because each incident costs less of your budget."
+---
+
+There are four different "MTT-" acronyms in incident management. They all sound similar, get used interchangeably, and measure completely different things. The result is engineering org-charts arguing about whose number is better when they aren't even measuring the same phenomenon.
+
+MTTR is the headline one - the average time from incident detection to service restored. It's the standard benchmark for how good a team is at handling outages. Here's what it actually measures, how it relates to the other three MTT-metrics, and how to actually move the number.
+
+---
+
+## The Four MTT-Metrics
+
+Most incident timelines have four phases. Each has its own metric.
+
+```
+Problem starts ──── Detection ──── Acknowledgment ──── Resolution
+ | | | |
+ └──── MTTD ─────┘ | |
+ └─── MTTA ──────┘ |
+ └─── MTTR ──────┘
+```
+
+### MTTD - Mean Time To Detect
+
+Time from the problem actually starting to your team noticing it.
+
+Driven by: monitoring quality, alert configuration, observability coverage.
+
+Low MTTD means your monitors caught it before customers did. High MTTD means you found out from Twitter.
+
+### MTTA - Mean Time To Acknowledge
+
+Time from the alert firing to a human acknowledging it.
+
+Driven by: on-call rotation quality, escalation policies, alert noise levels.
+
+Low MTTA means your on-call setup works. High MTTA usually means alert fatigue - too many noisy alerts, so real ones get ignored.
+
+### MTTR - Mean Time To Recovery (or Resolve)
+
+Time from detection to service being restored.
+
+Driven by: runbook quality, response process, recovery tooling, team experience.
+
+This is the headline metric. When people say "MTTR" they almost always mean this one.
+
+### MTTF - Mean Time To Failure
+
+Average time a system runs before failing.
+
+Driven by: overall reliability, change management, system design.
+
+Less commonly tracked. Requires a long incident history to be meaningful. Often used for hardware originally; less precise for software systems.
+
+---
+
+## How to Calculate MTTR
+
+The basic math:
+
+```
+MTTR = Total downtime across incidents / Number of incidents
+```
+
+**Example:** Last quarter you had 5 incidents. Their durations were 10, 20, 30, 45, and 120 minutes. Total: 225 minutes. MTTR: 225 / 5 = 45 minutes.
+
+The catch is defining "downtime." Two definitions in common use:
+
+- **Detection to resolution** - measures response speed. Excludes the time the system was broken before you knew.
+- **Impact start to resolution** - measures total customer-visible downtime. Includes [MTTD](/guides/what-is-mttr#mttd) inside it.
+
+Pick one. Be explicit about which. Don't switch between them.
+
+---
+
+## The Average Is Misleading
+
+The mean is a bad summary statistic for incident duration because the distribution is heavy-tailed.
+
+**Example:**
+- Team A: 10 incidents, all 30 minutes. MTTR = 30 minutes.
+- Team B: 10 incidents, 9 at 5 minutes and 1 at 280 minutes. MTTR = 32 minutes.
+
+The averages are nearly identical. Team B's customers are having a much worse experience.
+
+**Fix: track percentiles.**
+
+| Metric | Definition |
+|--------|------------------------------------------------|
+| P50 | Median incident duration - "typical" incident |
+| P95 | 95% of incidents resolved within this time |
+| P99 | The worst case you can plan around |
+
+A team with MTTR of 30 minutes and P95 of 35 minutes is consistent. A team with MTTR of 30 minutes and P95 of 4 hours is occasionally catastrophic. Same average. Very different reality.
+
+---
+
+## What's a Good MTTR?
+
+It depends on severity. A 4-hour MTTR is fine for SEV3. It's a crisis for SEV1.
+
+Rough benchmarks for SaaS:
+
+| Severity | Excellent | Typical | Needs work |
+|----------|-----------|------------|------------|
+| SEV1 | < 30m | 1-2h | > 4h |
+| SEV2 | < 1h | 2-4h | > 8h |
+| SEV3 | < 4h | Same/next day | > 1 week |
+
+The trend matters more than the absolute number. A team whose MTTR is dropping quarter over quarter is getting better. A team with low MTTR that's been flat for a year may just be in a quiet period.
+
+---
+
+## How to Actually Lower MTTR
+
+Three levers, each attacking a different part of the timeline:
+
+### 1. Faster Detection (Lower MTTD)
+
+- Better [synthetic monitoring](/guides/what-is-synthetic-monitoring) on critical paths
+- [Multi-region uptime checks](/guides/what-is-uptime-monitoring) for fast outage detection
+- Better internal observability - logs, metrics, traces
+- Alert on user-impacting symptoms, not just system internals
+
+Every minute of MTTD reduction is a minute off MTTR (if you measure impact-to-resolution).
+
+### 2. Faster Response (Lower MTTA + Active Response Time)
+
+- Clear on-call rotations with proper escalation
+- Reduce alert noise so real alerts don't get ignored
+- Runbooks for common incident types
+- Clear [incident management roles](/guides/what-is-incident-management) (incident commander, comms lead, SMEs)
+
+Most "we took too long to fix it" postmortems are actually "we took too long to figure out what was wrong."
+
+### 3. Faster Recovery (Lower Active Fix Time)
+
+- Feature flags to kill bad features without rolling back
+- One-click rollbacks for deploys
+- Automated runbooks for common recovery steps
+- Practiced runbooks (gameday exercises)
+
+The teams that recover fastest aren't necessarily the smartest - they've practiced the recovery steps until they're muscle memory.
+
+---
+
+## Common Mistakes
+
+**Reporting MTTR aggregated across severities.** A great MTTR for SEV3 hides a bad MTTR for SEV1. Always break down by severity.
+
+**Optimizing MTTR by downgrading severity.** When teams are graded on MTTR, the easiest way to "improve" is to call things lower severity. Watch for this. It's measurement gaming, not improvement.
+
+**Treating MTTR as the only metric.** A team with great MTTR but 10x the incident rate isn't better than a team with slower MTTR but fewer incidents. Track MTTR alongside incident frequency. Together they tell the real story.
+
+**Confusing recovery with resolution.** Service restored ≠ root cause fixed. Some teams measure MTTR to "service restored" and have a separate metric for "fully resolved" (which includes the follow-up engineering work). Either is fine - just don't mix them.
+
+**Ignoring the tail.** Reporting only the mean lets one bad outage hide in the data. Always look at P95 and P99.
+
+---
+
+## How MTTR Connects to SLOs
+
+MTTR shows up directly in your [SLO budget math](/guides/sla-vs-slo-vs-sli).
+
+If your SLO allows 43 minutes of downtime per month (99.9%), and your MTTR is 60 minutes, you can afford less than one incident per month before burning the budget. If your MTTR is 5 minutes, you can afford eight incidents and still stay within budget.
+
+Lower MTTR effectively buys you more deployment risk. Each incident costs less budget, so you can take more chances. This is why mature teams obsess over MTTR - it's the most leveraged metric for reliability improvement.
+
+---
+
+## The Bottom Line
+
+MTTR is the time from detection to recovery, averaged across incidents. It measures how good your team is at responding to and resolving outages.
+
+Track it by severity. Look at percentiles, not just the mean. Optimize the three levers - detection, response, recovery - to bring it down. And don't game it by silently downgrading incidents.
+
+The teams with the best MTTR aren't the ones who never have incidents. They're the ones who've practiced handling them.
+
+---
+
+**OpenStatus combines monitoring (lower MTTD) with status pages and alerting (lower MTTA) in one platform** - tightening the whole incident timeline.
+
+<ButtonLink href="https://app.openstatus.dev">Try openstatus free</ButtonLink>
+
+---
+
+Start free. No credit card required.
+
+---
diff --git a/apps/web/src/content/pages/guides/what-is-synthetic-monitoring.mdx b/apps/web/src/content/pages/guides/what-is-synthetic-monitoring.mdx
new file mode 100644
index 000000000..d2502510e
--- /dev/null
+++ b/apps/web/src/content/pages/guides/what-is-synthetic-monitoring.mdx
@@ -0,0 +1,184 @@
+---
+title: "What Is Synthetic Monitoring?"
+description: "Synthetic monitoring uses scripted, automated checks to simulate user behavior against your service from external locations. Here's how it differs from real user monitoring, the types of synthetic checks, and when each is worth running."
+author: "openstatus"
+publishedAt: "2026-05-07"
+category: "fundamentals"
+faq:
+ - question: "What is synthetic monitoring?"
+ answer: "Synthetic monitoring uses scripted, automated checks to simulate user actions against your service - hitting an API endpoint, loading a page, completing a checkout - from external locations on a fixed schedule. It catches problems before real users hit them, and it works even when you have zero traffic."
+ - question: "How is synthetic monitoring different from real user monitoring (RUM)?"
+ answer: "Synthetic monitoring runs scripted, fake traffic on a schedule from your monitoring provider's infrastructure. RUM captures data from actual user sessions in real time. Synthetic is proactive and deterministic; RUM is reactive and reflects real-world conditions. Most mature teams use both: synthetic for catching regressions early, RUM for understanding what real users experience."
+ - question: "What can you check with synthetic monitoring?"
+ answer: "API availability and response time, full page loads (with JavaScript execution), multi-step user flows (login, signup, checkout), SSL certificate validity, DNS resolution, third-party integrations, and end-to-end transactions that span multiple services. Anything you can script can be monitored."
+ - question: "When should I use synthetic monitoring instead of just uptime monitoring?"
+ answer: "Use synthetic monitoring (beyond simple uptime checks) when failure modes can't be detected by a single HTTP request. If your login flow depends on three services and any one of them being broken makes signups fail, a synthetic browser check that completes the full login is the only way to know it works end-to-end."
+ - question: "Does synthetic monitoring work without real traffic?"
+ answer: "Yes - that's one of its main advantages. Synthetic checks run on a schedule regardless of whether real users are hitting your service. This makes it ideal for pre-launch validation, low-traffic services, off-hours coverage, and detecting regressions in features that aren't used often."
+ - question: "What's a browser synthetic check?"
+ answer: "A browser check loads your page in a real headless browser (typically Chromium), executes JavaScript, and can click buttons, fill forms, and navigate multiple steps. It catches problems pure HTTP checks miss - broken JavaScript, third-party script failures, layout breaks, slow rendering - at the cost of running slower and using more resources."
+ - question: "How often should synthetic checks run?"
+ answer: "Simple HTTP checks: every 30 seconds to 1 minute. Browser checks: every 5-15 minutes (they're slow and expensive). Multi-step transaction checks: every 5-15 minutes. The more complex the check, the less frequent it makes sense to run - and the higher the value of each successful run."
+ - question: "What's a transaction monitor?"
+ answer: "A transaction monitor (also called a multi-step API check) runs a sequence of requests that depend on each other - log in, capture a token, use that token to make an authenticated request, validate the response, log out. It tests the whole flow as a unit, the way real users actually interact with your service."
+ - question: "Can synthetic monitoring replace real user monitoring?"
+ answer: "No. Synthetic monitoring tells you whether a controlled, scripted scenario works. RUM tells you what your actual users experience - including problems specific to their devices, browsers, regions, and ISPs. They answer different questions and complement each other."
+---
+
+Fake users, real signal. That's the trade synthetic monitoring makes - scripts that pretend to be real customers, executed on a schedule from external locations, so you find problems before your actual customers do.
+
+It runs even when you have no traffic. It tests what you actually care about - the login flow, the checkout, the API endpoint your largest customer depends on - rather than waiting for someone to complain on Twitter.
+
+---
+
+## How Synthetic Monitoring Works
+
+A synthetic monitor is a script that runs on a schedule from your monitoring provider's infrastructure. The basic shape:
+
+1. Probe servers (in different regions) wake up on a schedule
+2. Each runs the configured check - hit a URL, drive a browser, run a sequence of API calls
+3. The result (success/failure, latency, response body) gets recorded
+4. If checks fail across multiple regions, alerts fire
+
+The check itself can range from "GET /healthz, expect 200" to "load the homepage, fill in the signup form, complete payment, verify the receipt email" - all driven by a script.
+
+---
+
+## Types of Synthetic Checks
+
+### 1. HTTP / API Checks
+
+The simplest and most common. Make a request to a URL, validate the response.
+
+```
+GET https://api.example.com/v1/health
+Expect: 200, "ok" in body, response time < 500ms
+```
+
+Fast, cheap, easy to set up. The bread and butter of [uptime monitoring](/guides/what-is-uptime-monitoring). Doesn't catch frontend or JavaScript problems.
+
+### 2. Browser Checks
+
+A real headless browser (typically Chromium) loads your page, executes JavaScript, and can interact with the DOM. You can script clicks, form fills, and assertions.
+
+```
+Visit /login
+Type "[email protected]" in #email
+Type "..." in #password
+Click button[type="submit"]
+Assert URL is /dashboard within 5s
+```
+
+Catches problems that pure HTTP checks miss: broken JavaScript, third-party script failures, layout breaks, slow client-side rendering, cookie/auth bugs. Slower and more expensive to run, so used for critical user paths rather than blanket coverage.
+
+### 3. Multi-Step Transaction Checks
+
+A sequence of API calls that depend on each other, executed as one logical unit.
+
+```
+1. POST /auth/login -> capture token
+2. GET /api/me with token -> assert user_id
+3. POST /api/orders with token -> capture order_id
+4. GET /api/orders/{order_id} -> assert status="pending"
+```
+
+Tests the actual paths your customers integrate against. Catches problems where each individual endpoint works fine but the chain is broken (token format change, race condition, downstream dependency).
+
+### 4. Specialty Checks
+
+- **DNS** - confirm records resolve correctly and to the expected IP
+- **SSL** - validate certificate, check expiration date
+- **TCP/UDP** - confirm ports are listening
+- **gRPC** - check gRPC service health
+- **Ping** - basic network reachability
+
+Each fills a specific gap. Most teams use them sparingly.
+
+---
+
+## Synthetic vs Real User Monitoring (RUM)
+
+Two complementary approaches to understanding service health:
+
+| | Synthetic Monitoring | Real User Monitoring (RUM) |
+|-------------------------|-----------------------------|--------------------------------|
+| **Source of data** | Scripted probes | Actual user sessions |
+| **When it runs** | Fixed schedule | On every real user interaction |
+| **Works without traffic?** | Yes | No |
+| **Deterministic?** | Yes - same script each time | No - depends on user behavior |
+| **Catches what?** | Regressions, outages, third-party failures | Real-world conditions: devices, networks, geographies |
+| **Cost model** | Per-check | Per-session or per-event |
+
+Synthetic answers "does this scenario work?" RUM answers "what are users actually experiencing?"
+
+They complement each other. Use synthetic to catch issues before users do; use RUM to understand the long tail of problems specific to particular devices, browsers, or regions.
+
+---
+
+## When to Use Synthetic Monitoring
+
+**Use it when:**
+
+- You need to detect regressions before users do
+- Critical user paths must keep working (login, checkout, payment)
+- You have low or unpredictable traffic
+- You depend on third-party services and want to know when they break
+- You need pre-launch validation before a real-user rollout
+- Off-hours coverage matters (when no real users are around)
+
+**Skip it when:**
+
+- The endpoint is purely internal and only used by other monitored services
+- The check would be a duplicate of an existing one
+- The cost (time + money) exceeds the value of the signal
+
+The thing to optimize: signal per monitor. Fewer well-chosen synthetic checks beat a dashboard full of redundant ones.
+
+---
+
+## A Practical Setup
+
+A reasonable starting point for a mid-stage SaaS:
+
+- **HTTP checks** every 1 minute on: homepage, public API health endpoint, login endpoint, main authenticated API endpoints
+- **Browser check** every 10 minutes on: full login flow ending on the dashboard
+- **Transaction check** every 5 minutes on: API authentication sequence (token issue + authenticated call)
+- **Specialty checks**: SSL expiration warnings 30 days before, DNS validation hourly
+
+That's roughly 10-15 monitors. Enough to catch real problems. Not so many that alert fatigue sets in.
+
+For multi-region coverage, run each from at least 3 geographically distributed locations and require majority failure before alerting.
+
+---
+
+## Common Mistakes
+
+**Monitoring too many things.** Every monitor is an alert source. Every alert is an interruption. Be ruthless about pruning monitors that don't represent real customer impact.
+
+**No browser coverage on critical paths.** If signup or checkout depends on JavaScript, an HTTP check on the page returning 200 means nothing. Use a browser check on the actual flow.
+
+**Single-region monitoring.** A check that runs from one location lies to you when that location has network problems. Always require multi-region majority.
+
+**Treating synthetic results as ground truth.** Synthetic tells you whether your scripted scenario works. It doesn't tell you whether the user in Indonesia on a flaky 4G connection is having a good time. Pair with RUM for that.
+
+**Not updating scripts when the app changes.** Synthetic checks rot. A login flow check that's still using a deprecated form selector silently passes for weeks while users are actually broken. Treat synthetic scripts like code - review them, version them, update them when the underlying app changes.
+
+---
+
+## The Bottom Line
+
+Synthetic monitoring is how you find out something is broken before your customers tell you. The investment pays off the first time a synthetic browser check catches a failed deploy that an HTTP check would have shown as healthy.
+
+Start with HTTP checks on critical endpoints. Add browser checks for user flows that matter. Run from multiple regions. Push results to your [status page](/guides/what-is-a-status-page) so users have an authoritative source when things break.
+
+---
+
+**OpenStatus runs synthetic monitors - HTTP, TCP, DNS, and full browser checks - from multiple regions worldwide.** Open-source, with built-in status page integration.
+
+<ButtonLink href="https://app.openstatus.dev">Try openstatus free</ButtonLink>
+
+---
+
+Start free. No credit card required.
+
+---
diff --git a/apps/web/src/content/pages/guides/what-is-uptime-monitoring.mdx b/apps/web/src/content/pages/guides/what-is-uptime-monitoring.mdx
new file mode 100644
index 000000000..48304a5b3
--- /dev/null
+++ b/apps/web/src/content/pages/guides/what-is-uptime-monitoring.mdx
@@ -0,0 +1,171 @@
+---
+title: "What Is Uptime Monitoring?"
+description: "Uptime monitoring is the practice of continuously checking whether your service is reachable and responding correctly from outside your own network. Here's how it works, how uptime percentages are actually calculated, and what to monitor."
+author: "openstatus"
+publishedAt: "2026-05-06"
+category: "fundamentals"
+faq:
+ - question: "What is uptime monitoring?"
+ answer: "Uptime monitoring is the practice of regularly checking - usually every 30 seconds to 5 minutes - whether your service is reachable and returning the expected response. The checks run from external locations so they catch problems your internal infrastructure can't see, like DNS failures, certificate expirations, or regional outages."
+ - question: "How does uptime monitoring actually work?"
+ answer: "A monitoring service sends synthetic requests (HTTP, TCP, ping, or full browser sessions) to your endpoints from probe locations around the world on a fixed interval. If a request fails or times out, the monitor flags it. Most systems require multiple consecutive failures from different regions before alerting, to avoid noise from transient network blips."
+ - question: "What does 99.9% uptime mean in practice?"
+ answer: "99.9% uptime means roughly 8.76 hours of allowed downtime per year, or about 43 minutes per month. 99.99% drops that to 52 minutes per year. 99.999% ('five nines') is about 5 minutes per year - a target that's expensive to hit and usually only meaningful for infrastructure providers."
+ - question: "How often should I check my endpoints?"
+ answer: "For customer-facing services, every 30-60 seconds is standard. Less frequent (5-15 minutes) is fine for internal tools or batch systems. More frequent than 30 seconds rarely helps - you start measuring network jitter rather than real availability, and your costs climb fast."
+ - question: "Why monitor from multiple regions?"
+ answer: "An outage that only affects one region is invisible to a single-region monitor. CDN issues, DNS propagation failures, and regional ISP problems are common. Running checks from at least 3 geographically distributed locations and requiring a majority to fail before alerting catches real outages while ignoring isolated network blips."
+ - question: "What's the difference between uptime monitoring and synthetic monitoring?"
+ answer: "Uptime monitoring is the simplest form of synthetic monitoring - a periodic check that an endpoint responds. Synthetic monitoring is the broader category that includes multi-step browser flows, transaction monitoring, and API sequences. All uptime monitoring is synthetic monitoring; not all synthetic monitoring is uptime monitoring."
+ - question: "Should I monitor my homepage or my API?"
+ answer: "Both, separately. A working homepage doesn't mean your API is up - they often run on different infrastructure. Monitor the critical user paths: login, the main API endpoints your customers integrate with, payment processing. Each gets its own monitor so you know precisely what's failing."
+ - question: "What's a false positive in uptime monitoring?"
+ answer: "An alert that fires when nothing was actually wrong - usually because the probe location had a transient network problem, hit a rate limit, or got caught by a bot detection rule. Good monitoring tools reduce false positives by requiring multi-region confirmation and ignoring single-probe failures."
+ - question: "How is uptime percentage calculated?"
+ answer: "Uptime percentage is (total time minus downtime) divided by total time, expressed as a percent. The catch is defining 'downtime'. Some teams count only full outages; others include degraded performance. Be explicit: '99.9% uptime measured as HTTP 200 response in under 2 seconds from 3 of 5 regions' is meaningful. '99.9% uptime' alone is marketing."
+---
+
+Your internal dashboards say everything is fine. Your CPU graphs are flat. Your error rate is zero. But users in three countries cannot reach your API.
+
+This is the gap uptime monitoring exists to close. Send a request to your endpoint every minute from outside your own network, check the response, alert if something is wrong. The premise is simple. The interesting parts are in the details - what you check, how often, from where, and what counts as wrong.
+
+---
+
+## How Uptime Monitoring Works
+
+A monitoring service sits outside your infrastructure and makes synthetic requests to your endpoints on a schedule. The basic loop:
+
+1. **Probe** - send a request (HTTP GET, TCP connect, ICMP ping, DNS lookup)
+2. **Validate** - check the response (status code, latency, body content, headers, SSL validity)
+3. **Decide** - is this a failure? If yes, is it the second/third consecutive one?
+4. **Alert** - notify the on-call team via the channels they've configured
+
+The whole cycle repeats every 30 seconds to 5 minutes per monitor, from probe locations spread around the world.
+
+### Check Types
+
+- **HTTP/HTTPS** - the most common. Hit a URL, expect a status code, optionally validate the body.
+- **TCP** - confirm a port is accepting connections. Used for databases, message queues, custom protocols.
+- **Ping (ICMP)** - basic network reachability. Cheap, but doesn't tell you the application is healthy.
+- **DNS** - confirm a domain resolves correctly and to the right IP.
+- **Browser** - load the page in a real browser, run JavaScript, click through a flow. Slower and more expensive, but catches problems pure HTTP checks miss.
+
+Most teams use HTTP for the bulk of monitors and add browser checks for critical user paths like login or checkout.
+
+---
+
+## Why External Monitoring Matters
+
+Your internal monitoring tells you when servers are unhealthy. It cannot tell you when your service is unreachable from your customers' networks.
+
+Common problems that only external monitoring catches:
+
+- **DNS misconfiguration** - your records are wrong, but your servers are fine
+- **Expired SSL certificates** - the server responds, but browsers reject it
+- **CDN failures** - origin is healthy, edge is broken
+- **Regional ISP outages** - users in one country can't reach you
+- **Firewall rules gone wrong** - you blocked yourself from your own customers
+- **DDoS protection misbehaving** - legitimate traffic is being challenged
+
+A server with green internal metrics can still be completely unreachable for users. External probes catch that gap.
+
+---
+
+## What "99.9% Uptime" Actually Means
+
+The math, in case anyone asks:
+
+| Uptime | Downtime per month | Downtime per year |
+|-----------|--------------------|--------------------|
+| 99% | 7h 18m | 87h 36m |
+| 99.9% | 43m 49s | 8h 45m |
+| 99.95% | 21m 54s | 4h 22m |
+| 99.99% | 4m 22s | 52m 35s |
+| 99.999% | 26s | 5m 15s |
+
+A "three nines" SLA gives you about 43 minutes per month of allowed downtime. Four nines drops that to 4 minutes. Five nines is essentially "we cannot afford for this to ever go down" territory - very expensive to engineer and usually only meaningful for infrastructure providers like cloud regions or DNS.
+
+For most SaaS, 99.9% is realistic and defensible. 99.99% requires real investment - multi-region failover, automated recovery, careful deployment gates.
+
+For the gory details on what these numbers actually buy you, see [why uptime percentage is misleading](/guides/why-uptime-percentage-is-misleading).
+
+Want to compute the maximum downtime your SLA permits? Use our [uptime SLA calculator](/play/uptime-sla).
+
+---
+
+## Choosing a Monitoring Frequency
+
+| Frequency | Use case |
+|-----------------|---------------------------------------------------|
+| Every 30s | Customer-facing critical paths, payment APIs |
+| Every 1m | Most production APIs and dashboards |
+| Every 5m | Internal tools, background jobs |
+| Every 15m+ | Low-priority systems, cost-sensitive monitoring |
+
+Faster isn't always better. At 10-second intervals you start measuring network noise more than service health. Your false positive rate climbs and your cost goes up. Default to 1 minute unless you have a specific reason to go faster.
+
+---
+
+## Multi-Region Monitoring
+
+A single probe location lies to you. Networks fail. Probe servers have bad days. Bot detection rules sometimes catch monitoring traffic.
+
+The fix: run the same check from at least 3 regions on different continents, and require a majority to fail before alerting. This eliminates almost all false positives from transient probe-side issues while still catching real outages within seconds.
+
+If two of three regions in different continents can't reach your service, something is genuinely wrong. If one of three can't, it's almost always a network issue on the probe side - not your problem.
+
+---
+
+## What to Monitor
+
+Don't monitor everything. Monitor the things customers actually use.
+
+**Yes:**
+- Login and authentication endpoints
+- The main API endpoints your customers integrate with
+- Payment processing
+- The homepage (it's what people screenshot when complaining)
+- Critical multi-step flows (signup, checkout)
+
+**Maybe:**
+- Admin panels (only if your team relies on them constantly)
+- Internal tools used in customer support flows
+
+**No (or rarely):**
+- Marketing site pages beyond the homepage
+- Documentation
+- Anything that doesn't directly impact a paying customer if it's down for 30 minutes
+
+Each monitor costs money and generates alerts. Keep the list lean and the signal high.
+
+---
+
+## Uptime Monitoring vs Synthetic Monitoring
+
+Uptime monitoring is the simplest form of [synthetic monitoring](/guides/what-is-synthetic-monitoring) - one request, one response, did it work. Synthetic monitoring is the broader category that includes:
+
+- Multi-step browser flows ("can a user actually sign up?")
+- Transaction monitoring ("does payment processing complete end-to-end?")
+- API sequence monitoring ("does the OAuth dance work?")
+
+If you only need to know whether your endpoints respond, uptime monitoring is enough. If you need to know whether complex user journeys work, you need full synthetic monitoring.
+
+---
+
+## The Bottom Line
+
+Uptime monitoring exists because you cannot trust your own infrastructure to tell you when it's unreachable. The whole point is the external perspective - what does this look like to a user in São Paulo right now?
+
+Set it up. Monitor the things customers actually depend on. Use multiple regions. Tune the check frequency for the criticality. Push results into a [status page](/guides/what-is-a-status-page) so users can self-serve when things break.
+
+---
+
+**OpenStatus runs uptime monitors from multiple regions worldwide** and pushes results directly to your status page. Open-source, with sub-minute check frequency and no vendor lock-in.
+
+<ButtonLink href="https://app.openstatus.dev">Try openstatus free</ButtonLink>
+
+---
+
+Start free. No credit card required.
+
+---