OpsGenie is shutting down. And Atlassian recommends migrating to Jira Service Management (JSM).
But if you’re not sure JSM is the right fit for your team’s on-call management needs, this review will help you decide.
I signed up for JSM and put it through real-world testing. I created on-call schedules, rotations, and overrides. Then, I reviewed JSM’s on-call management across 4 key criteria.
For each criterion, I shared what I liked and what I didn’t. This gives you a balanced look at JSM’s on-call features.
As you finish reading this review, you’ll know if JSM fits your team’s needs. If you decide JSM isn’t right for you, I’ve also included an alternative that might suit you better.
Let’s dive in!
Table of Contents
Jira Service Management (JSM) Review: My On-Call Criteria
Here’s what I looked at to review JSM’s on-call features:
- On-Call Schedule Creation: I checked how fast you can create a new on-call schedule. I also looked for any starter templates to speed things up.
- On-Call Flexibility: I tested how simple it is to edit schedules for holidays or weekends. I also saw how it handles on-call shift changes.
- On-Call Dashboard & Visibility: I looked at the main dashboard to see how clearly it shows who is on call. I also checked if you can see upcoming shifts easily.
- On-Call Override Functionality: I tested how quickly you can override a shift. This is for when last-minute things like a dentist appointment come up.
Jira Service Management (JSM) Review for On-Call Management
| Criteria | What I liked | What I didn’t like |
|---|---|---|
| On-Call Schedule Creation | Side preview, multiple calendar views, straightforward setup | Team-centric structure feels nested, no ready-made templates |
| On-Call Flexibility | Can duplicate schedules and rotations, export to calendar, multiple edit options | Can’t mark schedules as favorites for quick access |
| On-Call Dashboard & Visibility | Multiple timeline views, search bar, see all schedules at once | No activity log for schedule changes |
| On-Call Override Functionality | Easy to create overrides, calendar interaction, “Take on-call” button | Can’t add comments to overrides, no override history |
1. On-Call Schedule Creation
JSM follows a team-based approach. You first add a team and then create an on-call schedule inside the team’s on-call dashboard.
What I liked
The preview appears right beside your configuration settings. This beats tools (like OpsGenie) that place previews at the bottom. You see changes immediately without scrolling.
JSM offers multiple timeline views (1 day, 1 week, 2 weeks, 1 month) plus a calendar view. Timeline views work for quick checks. Calendar view helps when you need a month-level overview. The setup walks you through each step clearly once you find where to start.
What I didn’t like
The team-centric structure adds extra navigation steps. You must create a team first, go to that team’s dashboard, and then create the schedule. This feels nested compared to platforms where schedules are created directly.
JSM doesn’t provide ready-made on-call templates. If you want to set up a common schedule, you build it from scratch every time. This slows down setup for teams that follow standard on-call models.
2. On-Call Flexibility
JSM lets you edit, duplicate, or delete schedules and rotations. You can turn schedules on and off, export them as ICS files, and add them to your calendar.
What I liked
The duplicate feature saves time when you need similar schedules for different teams. You clone one and adjust the details instead of rebuilding from zero. This works for both entire schedules and individual rotations.
Calendar export works well. You can download ICS files or add schedules directly to Google Calendar or Apple Calendar. This keeps everyone’s personal calendars in sync without manual updates.
What I didn’t like
You can’t mark schedules as favorites. If you manage multiple teams, finding the right schedule requires searching or scrolling through the full list every time.
3. On-Call Dashboard & Visibility
JSM provides an On-Call Schedules tab with two sections: “Your shifts” shows your coverage across schedules, and “All on-call schedules” displays every schedule with search and filters.
What I liked
The search bar and filters help you find schedules fast. You can filter by teams or people. Schedules appear in collapsible cards. The collapsed view shows the schedule name and timezone. The expanded view adds a timeline.
You get multiple timeline views (1 day, 1 week, 2 weeks, 1 month) plus a calendar view. When you click on a person’s name, you see their shift start and end times. This makes it easy to check coverage.
What I didn’t like
JSM doesn’t track schedule changes. When you create a schedule, add rotations, or make edits, these actions aren’t logged anywhere. You can’t see who made changes or when they happened.
This creates a major visibility gap. If something goes wrong with coverage, you have no audit trail to review what changed or who changed it.
4. On-Call Override Functionality
JSM lets you create overrides by clicking the “Add override” button or clicking directly on an on-call member’s name in the calendar. It also has a “Take on-call” button that makes you the only on-call person for one hour.
What I liked
Calendar interaction makes overrides fast. You click the person’s name and create the override right there. No need to go through menus or forms first.
The “Take on-call” button is useful for urgent situations. If you need to cover immediately, one click puts you on-call for an hour. You also get a separate timeline view that shows all overrides for that schedule in one place.
What I didn’t like
You can’t add comments to overrides. There’s no field to explain why you need coverage. The person filling in gets no context about the situation or what to watch for.
JSM doesn’t keep override history. While overrides appear in a separate timeline view, there’s no log to track who created them or when. This makes it hard to review past coverage changes or spot patterns.
So, Should You Consider Jira Service Management (JSM) for On-Call Management?
JSM gets the core of on-call management right. Schedule creation is straightforward once you find it. The side preview helps you see changes as you build. Duplication works well for teams that need similar schedules.
However, JSM has some notable gaps. You can’t add comments to overrides, so the person covering gets no context. There’s no activity log to track who made changes or when. The team-based structure feels nested and adds extra navigation steps.
The interface also lacks ready-made templates. If you want a common schedule, you build it from scratch every time. You can’t mark schedules as favorites, which makes finding the right one harder when you manage multiple teams.
Pick JSM only if these gaps don’t matter to your workflow. Otherwise, there’s a better alternative that fills the gaps JSM leaves behind, offers more flexibility, and comes at a lower cost.
Spike: A Better Jira Service Management (JSM) Alternative for On-Call Management
Spike is a modern incident management platform that includes powerful on-call features. It’s built to make on-call management simple and flexible.
Here’s why Spike is a better alternative to JSM for your on-call management:
- Unlike JSM’s nested team structure, Spike offers a clean, single-page UI with a live calendar preview right beside your configuration settings. Plus, it provides ready-to-use on-call templates to get you started instantly.
- With Spike, you clone entire schedules and star-mark your most-used ones for quick sidebar access. You can also add new layers with one click. The calendar preview updates immediately as you build.
With OpsGenie shutting down, businesses are switching to Spike with 50% off. Learn more →
- Unlike JSM’s missing activity logs, Spike provides full audit trails for every schedule change. You can see exactly who made what changes and when. It also keeps a separate history of all past overrides.
- Overrides in JSM lack context. But Spike lets you add comments to every override. The person covering for you knows exactly why they’re stepping in and what to watch for.
- Beyond basic overrides, Spike offers Out-of-Office and Cooldown modes. When you activate these, your duties automatically shift to the next person. No manual overrides needed.
- Spike supports webhook triggers when shifts start or end. You can automate health checks, create tickets in project management tools, or send shift summaries to the new on-call person.
- Spike integrates with Slack and Teams for on-call handover notifications, syncs with Linear to assign triage tasks to the current on-call person, and provides calendar sync through ICS files and WebCal feeds.
Read JSM vs. Spike: On-Call for a detailed comparison.
Virtually Human Moving From OpsGenie to Spike
Virtually Human creates consumer-focused entertainment with emerging technologies like blockchain. When they needed to replace OpsGenie, they picked Spike.
Steven Ryder, former Engineering Manager at Virtually Human, handled the switch to Spike. The move went smoothly with no disruption to their work.
Today, Virtually Human runs on-call schedules with 15 team members spread across 8 different time zones.
The global distribution of their team makes reliable on-call management critical. And Spike handles this complexity without issues.
Their migration proved that switching from OpsGenie doesn’t have to be complicated. With the right tool, teams can move quickly and get back to focusing on what matters.
Final Thoughts
JSM handles schedule creation, rotation management, and overrides without major issues.
However, it lacks key quality-of-life features. You can’t add comments to overrides, view activity logs, or access templates. These gaps make daily on-call management feel incomplete.
Spike fills these gaps and adds more convenience. It gives you faster setup, better visibility, and features that make on-call life easier.
With OpsGenie shutting down by April 2027, now’s the time to migrate on your terms. If you want a tool that handles the basics and adds quality-of-life features, Spike is worth a look.