Status Page Examples: What to Copy and What to Skip

Real status page patterns, incident message templates and a build checklist, so you can publish a page your customers trust before the next outage hits.

A good status page does four things: it shows current state by component, keeps a readable incident history, posts updates in plain language on a promised schedule, and stays up when your product is down. This guide breaks down the patterns worth copying, gives you message templates for each stage of an incident, and ends with a checklist for building your own.

Uptime Beacon
Keep Your Status Page Online
Uptime Beacon hosts public status pages independently of your dashboard, while monitoring helps reduce false alarms for your on-call team.
Explore Uptime Beacon

TL;DR

  • Show status per component (API, dashboard, webhooks), not one green light for everything.
  • Write updates as what users can’t do, then what you’re doing, then when the next update comes.
  • Announce planned maintenance well ahead, at least 72 hours for large-impact work.
  • Host the page so it doesn’t share fate with the app it describes.
  • Automate the boring parts (opening the incident, flagging components), keep a human in charge of the words.

Table of Contents

What a status page is for

A status page answers one question during an incident: is it us or is it you? Every minute a customer spends guessing is a minute they spend opening support tickets, refreshing your app or tweeting. A page that answers the question quickly takes that load off your support queue and, more importantly, protects trust.

It also serves a second audience: prospects and procurement teams. If you promise uptime to clients, your incident history is the receipt. An honest history with clear write-ups reads better than a suspiciously empty one.

What a status page is for — overview diagram

Status page examples worth studying

You don’t need a design studio. You need to borrow the right structures. Here are the patterns, with the kinds of pages that use them.

The component grid with uptime bars

The most familiar layout lists each component on its own row with a coloured bar for the last 90 days. Large developer platforms such as GitHub, Stripe and Cloudflare are often cited as good examples of this structure, and one industry guide highlights component breakdown and incident history as traits of the best pages. A catalog of system status pages shows the same shape: current state at the top, 90-day charts per service, a chronological log below.

What to copy: split components along how customers experience your product. “API”, “Web app”, “Webhooks”, “Scheduled jobs” help someone self-diagnose. “Server cluster 3” does not.

What to skip: dozens of components. If a row never changes independently, merge it.

The single-banner small-team page

A solo developer or a five-person SaaS doesn’t need twenty rows. One banner (“All systems operational” or the current incident), three to five components and a short history is enough. Small live pages, like the system status page for Genesis Engine, show how little you need to publish to give users a place to check.

The incident timeline

The part readers actually study during an outage is the timeline: investigating, identified, monitoring, resolved, each with a timestamp. Atlassian’s published incident template library is built around exactly these stages. Keep the stage names consistent so customers learn the vocabulary.

Color and status vocabulary

Green for healthy, yellow for moderate disruption and red for major disruption is a common coding. Stick to it. Add a text label next to every color, because color alone fails for colorblind readers and for anyone reading in a plain-text email.

The maintenance notice

Planned work deserves its own format, separate from incidents. Atlassian’s guidance is that large-impact maintenance should be announced well ahead, with reminders as the window approaches. In practice that means a notice at least 72 hours out, a reminder a day before and one when it starts. Small changes with no expected user impact need just one message.

Message templates you can adapt

Templates remove the blank-page problem at 3 a.m. Atlassian publishes incident communication templates from its own playbook, and simpli.support offers a comms pack covering acknowledgement through follow-up. Below are versions in our own words.

Investigating

Investigating: login errors We’re investigating reports that some users can’t sign in. The API and dashboard are otherwise responding. Next update by 14:30 UTC.

Identified

Identified: login errors We found the cause: a configuration change to our authentication service. We’re rolling it back. Users may still see errors for the next 10 to 15 minutes. Next update by 14:50 UTC.

Monitoring

Monitoring: login errors The rollback is complete and sign-ins are succeeding again. We’re watching error rates before closing this incident. Next update by 15:15 UTC.

Resolved

Resolved: login errors Sign-ins have been working normally since 14:58 UTC. Affected users were unable to log in between 14:05 and 14:58 UTC. We’ll publish a short write-up within three business days.

Planned maintenance

Scheduled: database upgrade, 12 November, 02:00 to 03:00 UTC During this window the dashboard will be read-only. Monitoring checks and alerts are unaffected. No action is needed on your side.

Notice what these have in common. They lead with the symptom in user terms, in line with openstatus’s advice to state plainly what users can’t do. They give a time, not “soon”. And every in-flight update ends with a deadline.

Best practices that hold up under pressure

Promise the next update and keep it

The strongest trust move during an incident is ending every entry with a “next update by” time and treating it as a hard commitment. Silence is what turns a short outage into a lasting trust problem. If you have nothing new, say so at the deadline: “Still investigating, no change.”

One voice, one owner

Contradictory messages are worse than slow ones. Atlassian’s write-up of practices from strong incident teams describes separating internal problem-solving chatter from external updates, and giving an incident commander sole authority to post to the public page. On a three-person team, that just means naming who writes the updates before the incident starts, not during.

Keep the page off the critical path

If your status page runs on the same stack as your app, it goes down exactly when people need it. Host it on separate infrastructure, ideally with separate DNS and a different provider for any custom domain. It’s the single most common design mistake we see described in postmortems.

Be specific, then be honest about scope

“Some users may be experiencing issues” tells nobody anything. Name the component, the symptom, the region or plan affected if you know it, and the start time. When you don’t know the cause, say that. When you do, say it briefly.

Automate the trigger, not the apology

Teams are moving toward status pages wired into monitoring and incident tooling. FireHydrant’s docs show incidents and updates being posted automatically from runbook steps, and the same tool can mark a component degraded when error rates cross a threshold or post a holding update if nobody has written one in 15 minutes. That’s a sound split: machines open the incident and keep the clock, people write the explanation.

Perspective: the page is only as good as the alert behind it

We run monitoring, so we see status pages from the other end. The most common failure isn’t ugly design. It’s a page that updates late because the first human to notice was a customer, or a page that flaps because the underlying alert was noisy.

That’s why we think the order of work matters. First, make your alerts trustworthy: an incident should open only after several consecutive failures, confirmed from a second location, so you aren’t paging someone, and publicly announcing an outage, over a network blip. Then connect that signal to your communication habit. A status page fed by a noisy check teaches customers to ignore it.

Perspective: the page is only as good as the alert behind it — overview diagram

Second, keep the page independent. Our status pages don’t depend on the dashboard, so they stay reachable when something goes wrong. Third, think about who’s on the other end of the incident. Many of our users now work with an AI assistant open. Over MCP, an assistant can read monitors, incidents and check history and diagnose a failing monitor region by region, which means the draft of your “Identified” update can start from facts rather than guesses. A human still decides what goes public.

Our founders have spent 30+ years combined running production in banking, fintech, telecom and SaaS, and the lesson repeats: customers forgive outages far more readily than silence.

— Aaditya Parashar

Instatus alternatives and how to choose a tool

People searching for alternatives to Instatus, Statuspage or similar hosted tools usually care about the same few things. Judge any tool, including ours, against this list.

Question Why it matters
Is the page hosted independently of your app? It must survive your outage.
Does it connect to monitoring? Manual-only pages update late.
Can you post maintenance windows? Planned work needs its own notice.
Where is the data stored? Matters for GDPR and procurement reviews.
What happens at your component count and subscriber count? Pricing often scales with both.
Is there a free tier you can test with? You should see it work before paying.

Open-source options such as Uptime Kuma and Cachet are on Checkly’s roundup of status page tools. They give you control, but you host them, which brings back the problem of keeping the page off your own critical path. If you self-host, put it on separate infrastructure from the app it reports on.

If you want monitoring and a status page from one place, Uptime Beacon includes public status pages on every plan, with one on Free. Every check result is stored in the EU, and the control plane and database are in the EU too.

How to build a status page in an afternoon

You can have a useful page live in a few hours. Here’s the sequence.

  1. List your components. Three to seven, named the way customers talk about your product.
  2. Set up monitoring first. Each component needs a check behind it: an HTTP check on the API, a TCP check on a port, a heartbeat for the cron job that sends invoices. If you run background jobs, our guide to cron job monitoring covers the pattern.
  3. Decide who posts. Name an owner and a backup. Write it in your runbook.
  4. Write the five templates above and save them where the on-call person can paste them.
  5. Choose independent hosting and a custom domain such as status.yourcompany.com, with DNS that doesn’t share fate with your main zone.
  6. Add a subscription option so customers get updates by email without checking the page.
  7. Test it. Run a fake incident, post all five stages, and read it as a customer would.
  8. Link it everywhere: footer, help center, error pages, API responses where sensible. For planned work, add an in-app banner that points to the page, as Atlassian suggests for maintenance.

If you need a broader plan for the first hour of an outage, see our incident response playbook checklist. To decide which numbers to publish afterward, read incident reporting metrics.

Mistakes that make a page worse than none

  • Marking everything green while users are complaining. Customers trust their own experience over your banner. Once they catch the mismatch, they stop checking.
  • Posting only when fully resolved. The value is in the in-between.
  • Jargon. “Elevated p99 on shard 4” belongs in the internal channel.
  • Blame or speculation. State what’s known.
  • Deleting embarrassing incidents. A history with gaps looks edited.
  • No end-of-incident note. Even two sentences on cause and prevention help.
  • Letting a flapping check drive the page. Require several consecutive failures and a second location before anything goes public.

Try it with Uptime Beacon

The Free plan costs 0 EUR per month with no card: 5 monitors every 5 minutes from EU Central, one alert channel (email or Slack) and one status page. Starter is 14.99 EUR per month, Pro 39.99 EUR and Business 89.99 EUR, and maintenance windows come with Starter and above. Second-location confirmation of failures is on paid plans. The MCP connection for AI assistants is on every plan, Free included. You can compare plans on the Uptime Beacon site, or read how SaaS teams use it for API and cron monitoring.

FAQ

What should a status page include at minimum?

Current status per component, a list of active incidents with timestamped updates, and a history of past incidents. Add a way to subscribe to updates and a clear contact path. Maintenance notices and uptime bars are worth adding once the basics work.

Should a small startup have a public status page?

Yes, as soon as customers depend on you. It takes little time to set up and it keeps support tickets down during incidents. A free tier is enough to start with, and you can add components as the product grows.

How often should I post updates during an incident?

As often as you promised in the previous update. End each entry with a specific next-update time and keep to it, even if the message is that nothing has changed. A fixed cadence matters more than a particular interval.

Can I use a status page template instead of writing from scratch?

Yes, and you should. Keep a set of templates for investigating, identified, monitoring, resolved and maintenance, then edit the specifics. Templates from Atlassian are a reasonable starting point, but rewrite them in your own voice.

Sources

Put your site on it. Sleep through the blips.

Add your first monitor now. If your site is fine, you will not hear from us.

Monitor it free
Sign up with GoogleOpening Google…
Free plan, no cardSign up with Google or email