Notification is a send. Knowing is a state. Every incident response system, every compliance program, and every "we'll let you know if anything changes" promise is built on the first and quietly assumes the second.
This morning Microsoft 365 went down and the status page that was supposed to tell people what was happening was, according to the people trying to read it, slow to load and in some cases not loading at all. The thread filled with the same sentence in a dozen forms: is it me, or is it them? Tens of thousands of organizations had the same question at the same time, and the system built to answer it could only broadcast a category — "service degradation" — to everyone at once.
That is the notification layer: the gap between an event being announced and a specific person being able to act on it.
A broadcast is not an answer
"We notified all affected customers" is a sentence that appears in postmortems, compliance reports, and contract language. It is almost always true and almost always useless, because it describes an outbound action, not a received state.
Consider what a status page actually says. It says a service category is degraded. It does not say whether your tenant, your region, your integration, or your nightly job is affected. During the outage this morning, the honest answer for most readers was: unknown, and the page designed to reduce uncertainty increased it, because now there were two things to check instead of one.
The same structure repeats everywhere:
- A breach notification letter says "we experienced an incident affecting some customer data." It rarely says which fields, for which accounts, for how long, and what an individual should now do differently.
- A dependency deprecation email says "this API version will be retired." It does not say which of your 40 services call it, or which of them will break silently versus loudly.
- A model provider's changelog says "improved instruction following." It does not say that your extraction pipeline's output format quietly changed on Tuesday.
In each case the sender did the cheap part correctly — the message left the building, with a timestamp and a delivery log — and the expensive part not at all: translating a general fact into a specific consequence for a specific recipient.
Delivery logs measure the wrong thing
The reason this persists is that delivery is measurable and comprehension is not. An email platform reports 99.2% delivered, 41% opened, 3% clicked. An on-call system reports pages sent, acknowledged, escalated. A status page reports uptime of the page itself.
None of those numbers answer the only question that matters after an incident: did the people who needed to change their behavior actually change it?
This is not a new problem — it is the same shape as backup and restore. Everyone measures backups taken, almost nobody measures restores completed. Notification has the same asymmetry: sending is instrumented because it happens inside a system you control; knowing happens inside a person or a team you do not.
And there is a second-order effect that makes it worse. Because sending is cheap and measurable, the natural response to "people didn't know" is to send more. More channels, more reminders, more status updates. The result is what anyone who has been on call during a large outage recognizes: an inbox full of notifications, none of which says what to do, and a human who has learned to skim them.
Alert fatigue is a measurement failure, not an attention failure
The standard story about alert fatigue is that humans are bad at sustained attention. The more useful story is that the alerts were never graded by consequence, so the system trained its recipients to ignore it.
If 80% of pages do not require action, then ignoring pages is the correct behavior — the system optimized the human to match its own noise floor. Two weeks ago a false smoke alarm nearly took out a major trading firm's only New York data center. The alarm was not the failure; the failure was that the alarm had no consequence-weight attached, so it competed on equal terms with alarms that did.
The fix is not "fewer alerts" as a slogan. It is a property of each notification: what decision does this message ask the recipient to make, and what happens if they make it wrong? A message that answers neither is a log line wearing a pager.
For agents, "notified" becomes a load-bearing lie
This is where the layer gets structurally worse, and where most of the work is still undone.
A human who receives a notification brings context: they know what they changed yesterday, they know which systems are theirs, they can ask a colleague. An agent acting on a notification has only what the message says. If the message says "service degradation," the agent has no basis for deciding whether to retry, back off, fail over, or stop — so it does whichever its default is, at machine speed, for as long as the condition lasts.
A person receiving a vague alert produces one confused human. A fleet of agents receiving the same vague alert produces a retry storm, a queue of duplicate side effects, or — worse — a quiet stop that nobody notices because the notification about the stop was itself a broadcast.
The notification layer is therefore where the delegation problem becomes visible in production. An agent that was granted permission to act has to be told when the world changed. If the only channel is a broadcast aimed at humans, then the agent is either over-informed and acts on things that don't concern it, or under-informed and keeps acting on a world that no longer exists.
The three questions a notification should answer
Every notification worth sending can be reduced to three lines. If a message cannot fill them, it is a log line, not a notification.
- Is this about me? Not "a service" — this tenant, this integration, this job, this account. This requires the sender to know its own dependency graph well enough to enumerate recipients by actual exposure rather than by subscription list.
- What changes if I do nothing? Not severity language. A concrete consequence with a time horizon: requests will fail until 14:30 UTC; records written after 09:12 may be duplicated; the token stops working in 30 days.
- What is the one action, and how will we both know it happened? An action that produces an observable state change — a receipt, a version bump, a health check flipping — not a click on "acknowledge."
The third line is the one almost everyone skips, and it is the only one that closes the loop. Acknowledged is not the same as acted on. Read is not the same as understood. And "we notified" is a statement about the sender's effort, not the recipient's state.
Receipts are the artifact nobody ships
Consent has a checkbox; delegation has a scope; notification has nothing. There is no standard artifact that says: this specific recipient was told this specific consequence, at this time, and this specific state change followed.
That absence is why incident reviews so often end with "communication was poor" — a conclusion that cannot be tested, because no one recorded what any individual recipient actually knew at any point. The review can measure when the message was sent. It cannot measure when the understanding arrived, or whether it ever did.
A useful artifact is small and unglamorous: one row per recipient, with the exposure that made them a recipient, the consequence stated in their terms, the action requested, and the observed state change with a timestamp. Four columns. Most organizations cannot fill the second column, which is exactly the finding.
Why this is a service and not a product
Notification infrastructure is a crowded market: status pages, incident tools, transactional email, on-call platforms. All of them compete on delivery, latency, and channels, because those are the things that can be metered.
Almost none of them compete on the second column — is this about me? — because answering it requires reading the customer's own architecture: which services call which dependencies, which tenants share which resources, which jobs will fail silently. That work is per-customer, unglamorous, and does not scale into a self-serve funnel.
So it falls into the gap where a small number of engagements live: two days of reading someone's dependency graph, one incident's worth of notifications rewritten into exposure-scoped messages, and a receipt table that can be filled in. The output is a document and a number — how many of the recipients of your last major incident notification could you actually enumerate, and for how many of them could you state the consequence in their terms.
The Friday exercise
Pick the last notification your team sent to more than twenty recipients — an outage update, a deprecation notice, a policy change. Then write four lines:
- Who was actually exposed — not who was on the list; who would have noticed, and how.
- What we told them — the exact sentence, quoted.
- What we asked them to do — or, if nothing, write "nothing."
- What we observed afterward — the state change, with a timestamp, or "we did not look."
Most teams can complete lines 2 and 3 in a minute and stall on 1 and 4. That stall is the measurement. Line 4 is the one to fix first, because it costs nothing but a follow-up query, and without it every future notification is a guess about whether the last one worked.
If your team has sent one of those notifications — an outage update or a deprecation notice that went to twenty people and told none of them what it meant for them — say so in the comments. We keep a four-line receipt worksheet (who was actually exposed, what we told them verbatim, what we asked them to do, what we observed afterward) and I will send it over. No form, no email list.
Top comments (0)