Two of the on-call tools engineering teams relied on for years are now on a countdown clock. Opsgenie stopped selling to new customers on June 4, 2025 and reaches full end of support on April 5, 2027. Grafana OnCall OSS — the free, self-hosted option a lot of smaller teams quietly ran — was archived on March 24, 2026, and its GitHub repository is now read-only. On top of that, Squadcast was acquired by SolarWinds in March 2025, which changes the long-term picture for anyone who picked it as their indie alternative.
So if you are reading this because your incident tooling is about to disappear and you need to pick a replacement, you are not alone. I have spent a good chunk of the last decade building and running systems that page people at 3 a.m. — including a Helpdesk Ticketing System and a ServiceBot AI Helpdesk for clients, plus the alerting around seven aggregator sites I run that pull 100 to 200 records each through daily imports. When one of those import jobs silently dies, I want to know before the client does. That is exactly the job these platforms do.
This comparison walks through the five tools most teams actually land on after Opsgenie and Grafana OnCall: incident.io, PagerDuty, Grafana Cloud IRM, Better Stack, and Rootly. I will also cover where Squadcast fits. Real pricing, the gotchas I have hit personally, and a decision matrix at the end.
Why your old tool is going away (the short version)
Atlassian wants Opsgenie customers to move to Jira Service Management (JSM) for incident response and Compass for service cataloging. The official migration page lays this out plainly. The problem teams keep running into: it splits one job across two products. During a live incident you do not want to bounce between JSM and Compass to figure out which service is on fire and who owns it. The JSM + Compass combo also does not bundle the monitoring layer Opsgenie users leaned on, so you end up bolting on a third tool.
Grafana's story is different but lands in the same place. Grafana folded OnCall and Grafana Incident into a single paid product called Grafana Cloud IRM. The open-source OnCall project that teams self-hosted for free is now archived — read-only, no new features. If you were running OnCall OSS to avoid per-seat pricing, that escape hatch is closed as of March 2026.
The takeaway from running production systems for a long time: free or "bundled with the suite you already pay for" tooling can vanish on a vendor's roadmap whim. When I pick alerting tooling now, I weigh how likely the vendor is to still care about the product in three years as heavily as I weigh features.
Quick verdict
- incident.io — Best all-in-one if your team lives in Slack and you want incident response + on-call in one place. Premium pricing.
- PagerDuty — The enterprise default. Most integrations, most mature. Also the most expensive once you add the pieces you actually need.
- Grafana Cloud IRM — Best if your observability already runs on Grafana. Active-user pricing is genuinely cheap for small rotations.
- Better Stack — Best value for small teams. Monitoring, on-call, incidents, and status page in one subscription with a real free tier.
- Rootly — Best low-cost Slack-native incident workflow tool, started at $15/user/month.
The pricing reality, side by side
Pricing is the single most cited reason teams switch. The pattern I see over and over: a team hits roughly $3,000/month on their current platform and starts shopping. Here is what each option actually costs in 2026, including the add-ons vendors like to hide behind "contact sales."
| Platform | Free tier | Entry paid price | On-call included? | 50-user all-in (monthly) |
|---|---|---|---|---|
| incident.io | Up to 5 users | $15/user (Team, annual) | Add-on: +$10/user (Team), +$20/user (Pro) | ~$2,250 (Pro, $45/user all-in) |
| PagerDuty | Limited (≤5 users) | $41/user (Business) | Yes (core) | ~$3,253 (with AIOps + Advance + Status Page) |
| Grafana Cloud IRM | 3 active IRM users | $20/active user + $19 platform fee | Yes | ~$1,019 (50 active users) + Grafana Cloud |
| Better Stack | 10 monitors, 1 phone alert | $29/responder (annual) | Yes | ~$1,450 (50 responders) + monitoring |
| Rootly | Trial | $15/user (start) | Yes (on-call module) | ~$750+ (varies by module) |
| Squadcast | Up to 5 users | $20/user (Pro, annual) | Yes (bundled all tiers) | ~$1,000 (Pro) |
One number worth sitting with: PagerDuty's Business plan is $41/user/month, which looks reasonable until you add AIOps ($699/month), PagerDuty Advance for AI features ($415/month), and Status Page ($89/month). For a 50-person team that turns $2,050 into $3,253/month — about $39,000 a year. incident.io's all-in Pro at $45/user lands near $2,250/month for the same 50 users with status pages and AI included. That single comparison is why so many SRE teams are mid-migration right now.
incident.io — the Slack-native all-in-one
incident.io was founded in 2021 by former Monzo engineers who were tired of fragmented legacy tooling. The whole product is built around one idea: the incident happens where your team already talks, which for most companies is Slack (Microsoft Teams is supported too). You declare an incident with a slash command, it spins up a channel, assigns roles, tracks the timeline, and writes most of your post-incident review for you.
The on-call piece used to be a separate product; it is now folded in as an add-on. Team plan is $15/user/month base plus $10/user for on-call. Pro is $25 base plus $20 for on-call, landing at the $45/user all-in figure. The free tier is genuinely usable for a tiny team — up to 5 users, one on-call schedule, a status page, and basic automation.
Where it shines: the post-incident workflow. If your culture cares about blameless retrospectives and actually closing follow-up actions, incident.io's automation here is the best of the group. The tradeoff I have seen: if your team does not live in Slack, a big part of the value evaporates. And the per-user-plus-add-on model gets expensive fast as headcount grows.
PagerDuty — the incumbent
PagerDuty is the tool everyone benchmarks against, and for good reason — it has the deepest integration catalog (700+), the most mature escalation logic, and a track record measured in well over a decade. If you need to wire alerts from an obscure monitoring system into a paging rotation, PagerDuty almost certainly has the connector.
The catch is cost and complexity. The base plan is capable, but the features teams assume are included — AIOps noise reduction, the AI assistant, hosted status pages — are separate line items. By the time you assemble a setup comparable to what newer tools bundle by default, you are at enterprise pricing. PagerDuty is the right call when you are a large org with heterogeneous tooling and a budget to match. For a 15-person startup, it is usually overkill.
When I set up alerting for the CyberShieldTips CVE pipeline — which aggregates roughly 3,000 CVE entries pulled from NVD — I did not need 700 integrations or AIOps. I needed one reliable path from "import job failed" to "my phone buzzes." That is the mismatch a lot of small teams feel with PagerDuty: you pay for a platform built for a problem you do not have yet.
Grafana Cloud IRM — the observability-native pick
If your dashboards and alerts already run on Grafana, Cloud IRM is the path of least resistance. It merges the old OnCall and Incident products into one, and the pricing model is refreshingly different: you pay $20 per active IRM user per month plus a $19 platform fee, with the first 3 active users free. "Active" matters — you only pay for people who actually engage with incidents in a given period, not every seat in your directory.
Worked example: 20 active IRM users costs $20 × 20 + $19 = $419/month, on top of whatever your Grafana Cloud bill already is. For a team with a small on-call rotation sitting inside a large org, that active-user model can be dramatically cheaper than per-seat pricing.
The honest downside: if you are not already a Grafana shop, adopting IRM means buying into the wider Grafana ecosystem to get full value, and the alerting/incident UX is more engineer-facing than the polished Slack-first experience of incident.io. For teams migrating off the now-archived OnCall OSS, though, IRM is the natural and lowest-friction landing spot.
Better Stack — best value for small teams
Better Stack is the one I keep recommending to small teams and solo operators, and it is closest to what I actually use for my own aggregator-site alerting. It bundles uptime monitoring, on-call scheduling, incident management, and status pages into a single product with a modern UI. The free tier includes 10 monitors with 3-minute checks and a phone alert — features that other vendors gate behind paid plans.
Paid monitoring starts at $29/month for 50 monitors with 30-second check intervals and unlimited phone/SMS alerts per Responder license. The responder/on-call seat is $29/month annual. For a team that wants "tell me when the site is down and page the right person" without standing up three separate subscriptions, the value is hard to beat.
Across the seven sites I run on Hostinger shared and VPS, the thing that actually matters is catching a failed nightly import or a 500 on an article page before traffic notices. A combined monitoring-plus-paging tool like Better Stack covers that in one place. My honest opinion: for anything under about 20 engineers, I would start here and only move to incident.io or PagerDuty when your incident process — not just your alerting — outgrows it.
Rootly — Slack-native, lower entry cost
Rootly is the closest direct competitor to incident.io: also Slack-native, also focused on incident response workflows, retrospectives, and automation. The pull is the entry price — Rootly starts at $15/user/month, undercutting incident.io's all-in Pro tier. If you want the Slack-driven incident experience but the incident.io quote made your finance team wince, Rootly deserves a head-to-head trial.
The two are genuinely close on core workflow, so the decision usually comes down to which automation builder and retrospective format fit your team's habits better, and which integrations you specifically need. Run both free trials with a real (non-production) incident drill before committing.
A note on Squadcast
Squadcast historically punched above its weight by bundling on-call, incidents, SLO tracking, and status pages at every tier — Free up to 5 users, Pro at $20/user/month annual, Premium at $29/user/month. It is still a strong product on features. The asterisk is the SolarWinds acquisition in March 2025. Acquisitions can go either way: more resources, or a slow drift in roadmap and pricing as the product gets absorbed. Given that you are likely reading this because a vendor decision upended your tooling, factor that uncertainty in. I would not rule Squadcast out, but I would weight vendor stability heavily after watching Opsgenie and Grafana OnCall both get pulled.
Migration: do not rush it
The single most useful piece of advice from teams who migrated off Opsgenie cleanly: start about six months before your cutover. The ones who started 3 to 4 months out reported rushed evaluations, integration failures they did not catch in testing, and — in at least one documented case — an actual incident during the cutover itself.
The proven approach is a parallel run:
- Stand up and fully configure the new platform alongside your old one.
- Dual-page critical alerts to both systems for 2 to 4 weeks.
- Validate that escalations, schedules, and overrides behave correctly under real load.
- Only then cut over and decommission the old tool.
I learned the hard way on a client Helpdesk Ticketing System migration that the dangerous failures are never in the happy path — they are in the escalation overrides and the timezone handling on rotation handoffs. Test those explicitly. Page yourself at 2 a.m. on purpose during the parallel run; if the escalation does not reach a human in the time you expect, you found a bug while it was still cheap.
Decision matrix
| If you are... | Pick | Why |
|---|---|---|
| A Slack-first team that wants incident response + on-call in one polished product | incident.io | Best post-incident automation; status pages and AI bundled |
| A large enterprise with diverse tooling and budget | PagerDuty | Deepest integration catalog, most mature escalation engine |
| Already running Grafana for observability | Grafana Cloud IRM | Lowest friction; cheap active-user pricing for small rotations |
| A small team or solo operator who wants monitoring + paging in one bill | Better Stack | Real free tier; best all-in value under ~20 engineers |
| Want the Slack-native experience at a lower entry price | Rootly | Starts at $15/user; close to incident.io on core workflow |
Frequently asked questions
When exactly does Opsgenie shut down?
New purchases and trials ended June 4, 2025. Full end of support is April 5, 2027. Teams on the Jira Service Management–bundled version lost access earlier, around October 2025. Atlassian's official path is JSM + Compass, but many teams move to a third-party platform instead to keep incident management unified.
Is Grafana OnCall still free and self-hostable?
No. The open-source Grafana OnCall project was archived on March 24, 2026 and the repository is read-only. Development continues only in the paid Grafana Cloud IRM. If you were self-hosting OnCall OSS to avoid per-seat costs, you will need to migrate.
What is the cheapest credible option here?
For small teams, Better Stack's free tier (10 monitors, one phone alert) or Grafana Cloud IRM's 3 free active users are the best zero-cost starting points. Among paid entry tiers, Rootly and incident.io's Team plan both start at $15/user/month before on-call add-ons.
incident.io vs PagerDuty — which is better in 2026?
incident.io if you are Slack-centric and want incident response and on-call bundled at a lower all-in cost. PagerDuty if you need its 700+ integration catalog and the most battle-tested escalation engine, and have the budget for the add-ons. For a 50-user team, incident.io's all-in Pro runs roughly $1,000/month less than a comparable PagerDuty setup.
How long should an incident-tooling migration take?
Plan for about six months end to end, with a 2-to-4-week parallel run where alerts page both the old and new systems. Teams that compressed this to 3 to 4 months reported significantly more failures during cutover.
Final take
The forced churn is annoying, but it is also a chance to stop overpaying for tooling you half-use. My order of operations: if you are small, start on Better Stack and only graduate when your incident process — not just alerting — demands more. If you are Slack-native and care about clean retrospectives, trial incident.io and Rootly side by side. If you already breathe Grafana, IRM is the obvious move off the archived OnCall OSS. And reserve PagerDuty for when you are genuinely enterprise-scale with the integration sprawl to justify it.
Whatever you pick, give the migration the runway it needs and test the escalation paths like your sleep depends on it — because eventually, it will.
