Home › Topics › Notification Routing & Channels › After-Hours Routing

After-Hours Routing: Schedules, Overrides, and Exceptions


An alert that fires at 2 PM on a Tuesday and an identical alert at 2 AM on a Sunday are, to the monitoring system, the same event. To the humans they are entirely different situations: different people available, different channels awake, and a wildly different price per interruption. Good routing knows three things the raw alert does not — what time it is, who is on duty, and what kind of day today is. It changes its behavior to suit.


This is the mechanics guide of the pillar. The strategy questions are settled elsewhere: which channel suits which urgency is channel matching. Why nights should be quieter at all is covered in quiet hours and alert tiers. Here we build the machinery that carries out those decisions around the clock. That means a layered schedule stack with one precedence rule and routing rules a colleague can read. It means exceptions that do not multiply and defenses against the specific ways time-based configuration fails.


One warning shapes everything that follows. Time-based routing drifts toward complexity. Every incident tempts you to add one more rule and every vacation one more special case. Eventually, the configuration is a haunted house nobody dares renovate. I inherited one of those once, and then, over four years, I built one. The goal is not clever routing. The goal is routing that the newest member of your team could explain on a whiteboard, because one day, possibly mid-outage, someone will have to.


In this guide

  • The schedule stack: four layers and one precedence rule
  • Routing rules people can actually read
  • Exceptions without regret
  • The four failure modes of time-based routing
  • The quarterly audit ritual
  • Worksheets: the stack and the audit

The schedule stack: four layers and one precedence rule


Every after-hours routing setup, whatever the tool, is some arrangement of the same four layers. Naming them separately is what keeps the arrangement understandable.


Layer 1: the business-hours calendar

The foundation is an explicit definition of "after hours" — and explicit is the operative word. "Evenings and weekends" is a vibe; a calendar is a rule. Write it as boundaries. Business hours are, say, Monday through Friday, 08:00 to 18:00, in a named time zone. Everything else is after-hours. Decide the edges deliberately, because the edges are where alerts land. Does 07:30 count as business hours because early birds are in, or as night because the on-call person owns everything before opening? Either answer works. Not choosing is what fails.


Layer 2: the holiday calendar

A holiday is a weekday wearing a weekend's clothes, and routing must see through the costume: org holidays route exactly like weekends. The classic failure is the forgotten-holiday page. A warning-level alert dutifully blasts the whole team's working-hours channels on a day nobody is working. Or worse, a routing rule assumes "someone is in the office" when the office is closed. Load your organization's holidays into the monitoring or routing tool as a calendar. Put a recurring task in December-or-whenever to load next year's list. Holiday calendars do not maintain themselves, and a stale one fails at the exact moment everyone is unreachable.


Layer 3: the on-call schedule

The layer that answers who: the rotation that says which human holds the pager right now. Routing reads this schedule and points the piercing channels — push, SMS, voice — at that person, while everyone else receives at most quiet visibility. The design of the rotation itself — fair shifts, sane lengths, a backup — is its own subject, covered in setting up your first on-call rotation. From routing's perspective the schedule is simply a function from "now" to "a phone number and a set of channels." The important property: it must never return nobody.


Layer 4: temporary overrides

Life happens on top of schedules: shift swaps, sick days, the vacation someone booked before joining the rotation. An override is a dated, bounded patch on the schedule. For example: "from Friday 18:00 to Monday 08:00, Dana covers instead of Mike." The override is entered in the tool, not agreed in a hallway. The swap protocols and courtesy rules around trading shifts live with the rest of the on-call craft in Escalation & On-Call. Routing's concern is narrower. Every override has a start, an end, and a name attached. The end matters most; failure mode two below is what happens without one.


At Tollgate Foods, two admins agreed a swap in the corridor on a Thursday: Priya would cover the holiday weekend so Tom could go away. Nobody entered the override. So on Saturday night, when the cold-store temperature alert fired, the schedule did what it was told and paged Tom. He was on a beach four hundred miles away with one bar of signal and his phone in a bag. The SMS arrived on Tuesday, when he got home. The escalation call had gone to the same phone. The review listed the routing as "functioning as configured". Priya, who had been awake and ready all weekend, was not told about any of it until Wednesday.


And the precedence rule that ties the stack together, stated plainly enough to recite: override beats schedule, schedule beats calendar, calendar beats default. When an alert fires, routing asks the layers in that order: is there an active override? If not, who does the on-call schedule name? What kind of day and hour is it, per the holiday and business calendars? And if nothing at all matches — the catch-all default answers. Write this sentence at the top of your routing documentation. It is the whole model.


Routing rules people can actually read


Inside the tool, the stack becomes routing rules — and rules are configuration, which means they rot unless tended. The hygiene that prevents rot is mostly editorial, not technical. Few rules. A small shop genuinely needs something like four to eight. If you are past a dozen, you are probably encoding exceptions that belong in severity design or in the schedule, not in routing. Named well. "Rule 7" tells the future nothing; "Criticals, after hours: page on-call" is documentation that happens to execute. Commented with intent. Every rule carries one line of why — because the person deleting a rule five years from now needs to know what it was protecting.


A full small-shop rule set, written as readably as most tools allow, looks about like this:


1. "Maintenance windows mute"
   during an announced maintenance window -> suppress
   # planned work must not page anyone

2. "Criticals, business hours"
   severity=critical AND business-hours -> chat + push to on-call
   # team coordinates in chat; push covers meetings

3. "Criticals, after hours"
   severity=critical AND NOT business-hours
   -> push + SMS to on-call; voice call if unacked 10 min
   # the 2 AM path; two channels, then escalation

4. "Warnings, business hours"
   severity=warning AND business-hours -> chat
   # visible today, interrupts no one

5. "Warnings, after hours"
   severity=warning AND NOT business-hours -> hold for morning digest
   # warnings never wake anyone, by design

6. "Catch-all"
   anything unmatched -> email to admin group + chat
   # nothing routes to nowhere; if this fires, fix a rule

Notice what makes that readable. The rules mirror the routing matrix cell for cell, and the names say what the comments explain. There is exactly one place where time is defined — the business-hours calendar — rather than times hard-coded into each rule. When the office hours change, one calendar edit updates everything.


The opposite smell is rule sprawl: forty rules, accreted incident by incident. They reference people who left and systems that were retired, in an order nobody fully understands. So nobody dares touch any of it, and new needs get met by adding rule forty-one. The escape is a periodic consolidation pass. Print the rules and map each to a matrix cell. Delete what maps to nothing, merge what maps to the same cell, and rewrite the survivors with names and comments. It is an hour of work that pays for itself the next time something misroutes at midnight.


Finally, test after every change, because routing has no compiler and misroutes fail silently. The good technique, where your tool allows it: fire a synthetic alert at a pretend time. A synthetic alert is one you create on purpose rather than one a real fault produced. Many tools can evaluate "what would happen to this alert right now?" or let you send a test alert while temporarily shifting the schedule. Confirm the path on the actual receiving device. Where the tooling cannot pretend, use the honest fallback: the next-real-alert watch. After any routing change, the person who made it explicitly watches the next genuine alert of the affected class and verifies it took the intended path. Write the verification down. "Changed Tuesday, confirmed Thursday on the disk warning" is a sentence that has saved careers.


Exceptions without regret


Every clean routing design meets reality within a month, and reality asks for exceptions. Grant them — sparingly, in patterns that cannot quietly multiply.


The pierce list. Some few alerts ignore quiet-hours routing entirely and page no matter the hour — the building is flooding, the whole site is down. This list earns its power by being tiny. If it grows past a handful of entries, it is not a pierce list anymore. It is your routing, and the quiet hours have quietly died. That is the design tension explored in quiet hours and tiers. Keep it in one place, visible, where its length embarrasses anyone padding it. Review it at the audit.


The VIP system, handled as a tier. Sooner or later comes the request: "anything on the CEO's printer pages immediately." Resist encoding personalities into routing. If a system is genuinely critical to the business, raise its alerts' severity. Then the ordinary rules do the right thing, and the routing config stays free of politics. The question "does this deserve to wake someone?" belongs in severity design, answered once, on the record — not re-litigated inside notification rules where nobody will ever find it again.


Heightened watch, with an expiry. Sometimes routing should tighten deliberately: the week after a major change, the night of a migration, the fragile stretch during an incident's aftermath. A heightened-watch mode — warnings temporarily page, or everything routes to two people — is legitimate if it carries an end date from the moment it starts. "Tightened until Friday" is an operational mode. "Tightened until someone remembers to relax it" is how shops end up permanently over-paged, wondering why on-call is exhausting. Never forever. Put the expiry in the tool if it supports it, in the calendar if it does not.


The four failure modes of time-based routing


Routing that knows the clock inherits the clock's bugs. Four patterns account for nearly all of them.


1. The timezone trap

Schedules exist in a time zone. Every component with an opinion about time — the monitoring server, the routing tool, the calendar, the phones — may hold a different one. The failure surfaces as routing that is off by exactly one or a few hours. For example, business-hours rules end while people are still at their desks, or the on-call handoff happens mid-evening. The policy fix is one sentence — all schedules are written and evaluated in one named zone — plus deliberate care if your organization spans zones (in which case: whose 18:00 ends the day?). And because much of the world shifts its clocks seasonally — daylight saving time, or DST — adopt the twice-a-year DST check. Each time the clocks change, glance at the next schedule boundary and confirm it lands where humans expect. Two minutes, twice a year, against a bug class that loves 2 AM.


2. The stale override

An override without an end date is a schedule change wearing a disguise. The classic is a sick-day override entered in a hurry — "route everything to Dana." It is still active a month later, with Dana silently carrying every night and the actual rotation a fiction. The discipline is absolute: every override has an end date at creation. No open-ended overrides, ever. An indefinite situation gets a one-week override renewed weekly, which keeps it visible and annoying enough to resolve. If your tool lists active overrides, that list is the first stop of the audit; if it does not, your routing one-pager carries the list.


3. The gap between shifts

Boundaries are where coverage quietly tears. A schedule that ends one shift at 08:00 and starts the next at 08:00 should be seamless. But tools differ on inclusive versus exclusive boundaries, and handoffs get edited independently. A schedule maintained by hand can end Sunday at 18:00 against a Monday shift starting 08:00. That leaves fourteen unowned hours nobody notices until an alert falls into them. Defenses: prefer schedules generated by rotation rules over hand-placed blocks. Where hands are involved, make handoffs overlap by a few minutes rather than merely touch. And state the boundary rule in writing — "the incoming person owns alerts from 08:00:00 sharp." Then test an alert at the boundary once, and trust the result over the assumption.


4. The unrouted severity

Rules match what existed when they were written. Then a new alert class appears — a new severity level, a new device group, a differently-formatted source — and matches nothing. In too many tools "matches nothing" means "goes nowhere," silently. The defense is the catch-all default, rule six above: everything unmatched goes somewhere visible — an email plus a chat post is plenty. The appearance of anything in the catch-all is itself a finding, meaning a rule is missing. A catch-all that delivers into a monitored place converts an invisible routing hole into a mildly annoying to-do, which is the entire trick. Test it by sending a deliberately unmatched alert; a catch-all you have never seen fire is a hope, not a rule.


Tip: all four failure modes share one property: the system looks fine while broken. That is the same silent-failure family as dead webhooks and expired SMS accounts. And the same cure applies — scheduled end-to-end tests, covered in delivery reliability. Time-based routing simply adds "at the right time, to the right person" to the definition of a passed test.


The quarterly audit ritual


The stack decays at human speed: people leave, hours shift, and holidays refresh annually. So it gets audited at human speed: quarterly, half an hour, walked top to bottom against the precedence order. Confirm the calendars still describe reality (office hours, next quarter's holidays loaded). Confirm the on-call schedule matches the humans who actually work here and their current numbers and devices. Expire every override that has outlived its story. Recite the pierce list out loud and defend each entry. Fire the catch-all test. And check the boundary of the next clock change if one falls in the quarter.


Then update the routing one-pager. This single page states the precedence sentence, the business-hours definition, the current rule list with intents, and the pierce list. It also states where each of these lives in the tooling. Its audience is whoever inherits this system — the new hire, the consultant, or you in three years. Its quality metric is whether that person could answer "who gets paged at 3 AM on a holiday, and why?" from the page alone. If the one-pager and the tool ever disagree, the audit's last act is making them agree.


Worksheets: the stack and the audit


Two tables to fill in and keep with the one-pager. First, the stack worksheet — one row per layer, answered for your shop:


LayerBeatsDefined whereOwnerRefreshed
4. Overrides (swaps, sick, vacation)Everything belowRouting tool's override listWhoever creates one — with an end dateExpire on end date; reviewed quarterly
3. On-call scheduleCalendars, defaultRotation in the toolTeam leadContinuous; verified quarterly
2. Holiday calendarBusiness-hours calendarCalendar in the toolNamed adminAnnually, next year loaded in advance
1. Business-hours calendarDefault routingOne calendar, one named time zoneNamed adminOn policy change; DST-checked twice yearly
0. Catch-all defaultNothing — it is the floorLast routing ruleNamed adminTest-fired quarterly

Second, the audit checklist — the quarterly half hour as a table you can initial and date:


#Audit stepPass looks like
1Business-hours calendar vs realityHours and time zone match how the team actually works
2Holiday calendarRest of this year and the next loaded and routing as weekends
3On-call scheduleRight humans, current phone numbers, no gaps at boundaries
4OverridesEvery active override has a future end date and a live reason
5Pierce listStill tiny; every entry defended out loud
6Heightened-watch modesNone running without an expiry
7Catch-allTest alert with no matching rule arrived somewhere visible
8Rule count and namesUnder a dozen, named, commented; sprawl gets a consolidation pass
9One-pagerUpdated; a newcomer could answer the 3 AM question from it

Where to go next


After-hours routing is where this pillar's ideas become machinery. The channel matrix supplies the what. The schedule stack supplies the who and when. And delivery reliability proves the whole path before 3 AM does. If the on-call rotation underneath is still taking shape, your first rotation and the rest of Escalation & On-Call build that half. The full set of guides lives at Notification Routing & Channels. When you are done, hand the newest person on the team a marker and ask who gets paged at 3 AM on a holiday. If they can draw it, you are finished.


Put this into practice with SysPeep Monitor

The machinery in this guide needs alert rules worth routing. SysPeep Monitor gives you thresholds, dependencies and alert rules designed to keep noise down. Notifications by email and other channels are sent according to the rules you define. That gives you a solid base under any schedule stack. The free trial installs on a Windows machine in minutes.

Download Free TrialLearn About SysPeep