When your website or app goes down, there are really two problems to solve. First: how do you find out before your customers do? Second: if it's down for more than a few minutes, what do you tell people who are asking? "Uptime monitoring" solves the first problem — something pings your site every minute or so and alerts you the second it stops responding. A "status page" solves the second — a public page where you can honestly say "yes, we know, here's what's happening" instead of going silent while your inbox fills up.
We looked at five real tools that tackle this in very different ways — from a plain-language checker built for non-technical site owners, to a free self-hosted option for engineering teams who don't want another subscription. Here's how they compare.
| Tool | Best for | Pricing | Free tier? |
|---|---|---|---|
| PlainPing | Non-technical site owners who just want plain-language alerts | Free, then $9–$19/mo | Yes, real free tier |
| Larm | Engineering teams who want fewer false-positive alerts | Free, then $19–$49/mo | Yes, 15 monitors free |
| Upright | DevOps teams who'd rather self-host than pay a subscription | Free and open-source (MIT) | Yes — you just pay for hosting |
| StatusPal | Teams that need a polished public status page, not just alerts | $46–$299/mo, 14-day trial | No permanent free plan |
| SmokeOps | Git-native teams who want checks defined and versioned as code | Free and open-source (Apache 2.0) | Yes — you provide the compute |
PlainPing: monitoring that doesn't assume you're technical
Most uptime tools are built for engineers. PlainPing is built for the small business owner or freelancer who just wants to know, in plain English, if their site is down — or if an SSL certificate or domain registration is about to expire and quietly take the site offline. Setup is just pasting in a URL.
Forces: alerts written in plain language instead of jargon, a genuinely usable free tier, SMS alerts starting at just $9/month, and setup that takes seconds.
Limits: it only tracks three things — uptime, SSL, and domain expiry — and caps out at 10 sites even on the most expensive plan, so it's not built for agencies managing many clients.
Verdict: pick PlainPing if you run one or a few sites and want alerts you don't need a technical dictionary to understand.
Larm: fewer 3am false alarms
Larm's whole pitch is reliability of the alert itself: instead of paging you the moment one server in one location can't reach your site, it checks from four continents and only alerts once an outage is confirmed from multiple locations. That means a single flaky network route somewhere in the world won't wake you up for nothing. It also captures detailed request traces (DNS, TCP, TLS, TTFB) so you're not just told "it's down" — you get a head start on why.
Forces: multi-continent verification cuts false positives, detailed request-level tracing, monitors HTTP, TCP, DNS and cron/heartbeat checks, and status pages with 90-day history included.
Limits: the free tier is capped at 15 monitors checked every 3 minutes, it's lighter on incident management than a full platform like Better Stack, and cost climbs at the Business tier for higher volume.
Verdict: pick Larm if your team is tired of being paged for flaky-network false alarms and wants trace-level detail when something really breaks.
Upright: free forever, if you're willing to run it yourself
Upright is a different kind of answer entirely: it's free, open-source (MIT license), and self-hosted, built by Basecamp. Instead of paying a monthly fee to a vendor, you deploy it to your own server (via Kamal, on any VPS) and it runs real browser checks — not just "did the server respond," but full logged-in user flows, with video capture when something fails. It exports natively to Prometheus and OpenTelemetry, so it plugs straight into a Grafana setup you might already have.
Forces: completely free with no recurring subscription, real Playwright-powered browser checks including login flows and video-on-failure, native Prometheus/OpenTelemetry export, and multi-region deployment on infrastructure you control.
Limits: there's no managed dashboard or vendor support — it's entirely on your team to run, it requires real ops skills (Rails, Kamal, Prometheus), and there's no turnkey cloud version if you just want an alert in five minutes.
Verdict: pick Upright if your team already self-hosts infrastructure and would rather own this than pay for it monthly.
StatusPal: for when you need to tell customers, not just yourself
StatusPal bundles monitoring, incident management, and a hosted public status page into one subscription — the page where, during an outage, you tell customers "yes, we know, here's what's happening" instead of leaving them guessing. It supports a custom domain, multilingual pages, and SSO on higher tiers, aimed at teams that treat outage communication as a real part of the product.
Forces: monitoring, incident management and a public status page in a single subscription, a 14-day free trial with no card required, multilingual support, and SSO from the Business plan.
Limits: pricing starts at $46/month and climbs fast to $99 then $299 depending on team size and subscriber count, there's no permanent free plan for a simple public status page, and against Atlassian Statuspage or Instatus, the differentiation is mostly on entry price.
Verdict: pick StatusPal if communicating outages publicly matters as much as detecting them, and you're prepared to pay for that polish.
SmokeOps: checks defined in plain English, versioned like code
SmokeOps takes the newest approach here: describe a critical user flow in plain language, and it turns that into an approved, schedulable browser check — without anyone having to hand-write Playwright scripts. Checks live in your repo and are versioned like code, and once a check is approved, it runs without depending on an LLM at all. It's very early — created in late July 2026 — so treat it as a promising bet, not a mature tool.
Forces: completely free and open-source (Apache 2.0), no LLM dependency once checks are approved, checks stored and versioned in your own repo, and automatic screenshots and traces captured on failure.
Limits: it's a very young project with essentially no track record or community yet, there's no support to fall back on, and there's no built-in alerting or history dashboard — you assemble that yourself.
Verdict: pick SmokeOps if you want to write monitoring checks the way you write code, and you're comfortable being an early adopter.
Which one should you actually pick?
If you're not technical and just want to know when your site is down, start with PlainPing — it's built for exactly that. If you're an engineering team that wants reliable alerts without false alarms, Larm's multi-continent checks are worth the free tier alone. Teams that already self-host and want to avoid another subscription should look at Upright. If public-facing communication during outages matters to your business, StatusPal is built for that specifically. And if you like the idea of monitoring-as-code and don't mind being an early adopter, SmokeOps is worth watching. None of these replace good incident response — they just make sure you (and maybe your customers) find out fast.