Atlassian announced it is sunsetting Opsgenie as a standalone product, folding its on-call features into Jira Service Management. If your team runs on Opsgenie today, you have a deadline — and a decision.
The forced migration is an opportunity to re-evaluate. Opsgenie was a solid mid-market on-call tool, but the market has changed since most teams adopted it. Newer entrants like incident.io and Rootly have reimagined how on-call connects to incident response. Grafana OnCall made open-source on-call viable. PagerDuty matured its platform further. And Atlassian's own JSM absorbed Opsgenie's features into a broader ITSM surface.
This guide compares six alternatives on the dimensions that actually matter for an on-call rotation: scheduling flexibility, escalation depth, integration breadth, pricing model, mobile experience, and how well each tool connects to the rest of your incident workflow.
What to look for in an Opsgenie replacement
Before comparing tools, clarify what your team actually needs. Opsgenie covered a broad surface — on-call scheduling, escalation policies, alert routing, and integrations with monitoring tools. Not every replacement covers all of it equally well.
On-call scheduling. The basics are table stakes: rotations, overrides, time-of-day restrictions. The differentiators are schedule previews, gap detection, and how painful it is to set up a follow-the-sun rotation across three time zones.
Escalation policies. How many levels can you define? Can you branch based on alert severity or service? Can you escalate to a Slack channel instead of a person? Some tools treat escalation as a linear chain; others allow conditional routing trees.
Integration count and quality. Opsgenie had 200+ integrations. If your monitoring stack sends alerts through a specific integration, verify the replacement supports it natively — not just via generic webhook. Native integrations carry metadata (severity, service, deduplication keys) that generic webhooks lose.
Pricing model. The industry split is per-seat vs. usage-based. Per-seat is predictable but punishes large on-call rosters where most people are only paged occasionally. Usage-based (per-incident or per-notification) is cheaper for large teams but can spike during outages — exactly when you need the tool most.
Alert routing intelligence. Can the tool suppress duplicates? Correlate related alerts? Auto-resolve when the source clears? Route based on alert content, not just the integration it arrived on? Opsgenie's alert policies were underrated — make sure your replacement covers the same ground.
Mobile app quality. On-call is a mobile-first job. The acknowledge-and-escalate flow needs to work reliably on a lock screen notification at 3 AM. Test the mobile app before committing.
PagerDuty
PagerDuty is the incumbent and the most mature platform in the category. It has been doing on-call since 2009, and the depth shows — 700+ integrations, multi-level escalation with conditional branching, event intelligence (ML-based alert grouping and suppression), and a mobile app that has had fifteen years of iteration.
The escalation engine is the deepest in this list. You can define policies that route by urgency, time of day, and service. The event orchestration layer lets you transform, suppress, or re-route alerts before they page anyone. If you have complex routing needs — "page the database team for Postgres alerts, but only if severity is critical and it's outside business hours" — PagerDuty can express that without custom code.
The downside is cost. Plans start at $21/user/month for the base tier and reach $49/user/month for the full platform (AIOps, analytics, status pages). For a 20-person on-call roster, that is $5,000–12,000/year. The platform also carries the weight of its age — the UI has layers of legacy concepts, and configuring event orchestration requires working through a learning curve that newer tools avoid.
Best for: mid-to-large engineering orgs with complex routing needs, deep integration requirements, and budget for the premium tier. Overkill for a 5-person startup.
Grafana OnCall
Grafana OnCall is the open-source option. You can self-host it (Apache 2.0 license) or use the managed version on Grafana Cloud, which includes a free tier for up to 100 users.
The primary value proposition is native integration with the Grafana ecosystem. If you already use Grafana for dashboards and Grafana Alerting for your alert rules, OnCall plugs in without a new vendor relationship. Alerts flow directly from Grafana Alerting into on-call schedules and escalation chains — no webhook glue required.
The scheduling and escalation features cover the essentials: rotations, overrides, multi-step escalation, and notification through Slack, Telegram, phone, and SMS. The web UI is clean and functional. Where it lags behind PagerDuty is in the edges — the mobile app is newer and less polished, the alert routing logic is simpler (no ML-based grouping), and the integration catalog outside the Grafana ecosystem is smaller.
Best for: teams already invested in Grafana that want on-call without adding another vendor or another bill. Also strong for teams that value open source and want the option to self-host.
incident.io
incident.io started as an incident management tool and expanded into on-call. The result is a product where on-call and incident response are tightly coupled — when a page fires, the same tool handles the response, the communication, and the retrospective.
The differentiator is Slack-native workflows. Declaring an incident creates a dedicated channel, assigns roles, posts status updates, and tracks action items — all without leaving Slack. The on-call layer feeds directly into this: when an alert fires and nobody acknowledges, escalation can auto-declare an incident with the full response machinery attached.
On-call features include rotations, escalation policies, and a catalog-driven routing model where you define services and link them to teams. Pricing starts at $20/user/month for the on-call product, with incident management as a separate (or bundled) line item.
Best for: teams that run their incident response in Slack and want on-call tightly integrated with the declare-respond-retrospect lifecycle. Less compelling if your team uses Microsoft Teams or prefers a standalone on-call tool.
Rootly
Rootly occupies similar territory to incident.io — incident management with on-call — but differentiates on AI-powered retrospectives and broader chat platform support (both Slack and Microsoft Teams).
The incident timeline is the standout feature. Rootly automatically constructs a chronological record of actions taken during an incident — who was paged, what was acknowledged, which runbooks were triggered, what messages were posted. The retrospective template then pulls from this timeline, reducing the manual work of writing a postmortem.
On-call scheduling and escalation are solid but not as deep as PagerDuty's. The integration catalog is growing but smaller than the incumbents. Pricing is competitive with incident.io.
Best for: teams that value automated retrospectives and want incident management + on-call in one tool. Particularly relevant if your organization uses Microsoft Teams, where incident.io's Slack-native approach is a non-starter.
Better Stack
Better Stack takes a bundled approach: uptime monitoring, on-call, incident management, and status pages in one product. If you want to consolidate vendors — replace Opsgenie and your uptime monitoring tool at the same time — Better Stack is the most integrated option.
The on-call features are competent: rotations, escalation policies, multi-channel notifications (phone, SMS, Slack, Teams, email). The scheduling UI is straightforward. What makes it interesting for Opsgenie refugees is the monitoring layer underneath — you get HTTP, keyword, and heartbeat checks that feed directly into on-call without configuring a separate integration.
The trade-off is depth. Better Stack's on-call is solid for straightforward routing (alert fires, page the on-call engineer, escalate if unacknowledged), but it lacks the conditional routing and event orchestration that PagerDuty offers. For teams with simple on-call needs and a desire to reduce vendor count, that trade-off is acceptable.
Best for: small-to-mid teams that want monitoring + on-call + status pages in one subscription. Not for teams with complex multi-service routing needs.
Jira Service Management (JSM)
JSM is Atlassian's own migration path. The on-call features in JSM are, in large part, Opsgenie's features rebuilt into the JSM platform. If you are already paying for JSM Cloud, you get on-call included at no additional cost on Premium and Enterprise plans.
The integration with Jira is the obvious advantage. Alerts can create Jira issues. Incidents link to change requests. The service catalog connects to your CMDB. If your organization's workflow revolves around Jira, the operational data staying in the same platform has genuine value.
The downsides: JSM is an ITSM tool first, and on-call is one feature among many. The configuration surface is large, the UI carries Jira's complexity, and the mobile experience for on-call is embedded within the broader JSM app rather than being a focused paging tool. For more on the Opsgenie shutdown timeline and migration planning, see our detailed breakdown.
Best for: organizations already on Atlassian Cloud (Jira, Confluence, JSM) that want the simplest migration path and value tight Jira integration over a standalone on-call UX.
Migration decision framework
| Dimension | PagerDuty | Grafana OnCall | incident.io | Rootly | Better Stack | JSM |
|---|---|---|---|---|---|---|
| Starting price | $21/user/mo | Free (Cloud) | $20/user/mo | Custom | $29/mo (team) | Included w/ JSM Premium |
| Integrations | 700+ | 50+ (Grafana-native) | 100+ | 80+ | 100+ | 200+ (Jira ecosystem) |
| Slack-native | Partial | Yes | Yes | Yes | Partial | No |
| Teams support | Yes | Yes | No | Yes | Yes | Yes |
| Open source | No | Yes (Apache 2.0) | No | No | No | No |
| Bundled monitoring | No | Yes (Grafana Cloud) | No | No | Yes | No |
| Mobile app maturity | High | Medium | Medium | Medium | Medium | Medium |
| Event orchestration | Deep | Basic | Catalog-based | Basic | Basic | Moderate |
There is no single best tool here. The decision depends on your existing stack:
- Already on Grafana? Grafana OnCall is the lowest-friction path.
- Run incidents in Slack? incident.io or Rootly, depending on whether you need Teams support.
- Want the deepest routing engine? PagerDuty.
- Want to consolidate monitoring + on-call? Better Stack.
- Already paying for JSM Cloud Premium? JSM is free and familiar.
- Budget-constrained? Grafana OnCall (free) or JSM (included).
Whichever tool you choose, the on-call layer is only as good as the alerts feeding it. Noisy, low-context alerts create alert fatigue regardless of how well the escalation policy is configured. The monitoring system upstream — what generates the alerts, how it classifies severity, and how quickly it detects problems — determines whether your on-call engineers get paged for real incidents or wake up for false positives.
The monitoring layer underneath
Your on-call tool routes alerts. Something else has to generate them.
For the multi-region monitoring and alerting layer that feeds your on-call tool — HTTP, DNS, TCP, and heartbeat checks with configurable notification policies and a public status page — take a look at DevHelm. Your first 50 monitors are free, with checks running from multiple regions and alerts routed to whichever on-call platform you picked from this list.
Originally published on DevHelm.
Top comments (0)