my-iris app + voice call
The escalation engine that reaches a human
Most alerting is send-and-forget. my-iris treats every alert as a stateful state machine — a Durable Object that routes, notifies, waits, escalates and resolves, then proves it happened. Not a fragile chain of automations that breaks at 2 AM.
- Anna — push 02:00 · call 02:05 · no answer
- Mikael — push 02:06 · awaiting
- Priya — next in line
The lifecycle
One stateful flow, signal to proof
Each alert lives as a single Durable Object that holds its own state across every step — so timing, attempts and answers are reliable by design, not by polling.
- Annapush 02:00 · call 02:05 · no answer
- MikaelEscalatingpush 02:06 · awaiting
- Priyanext in line
- 01received
Ingest
A sensor, monitoring system or script posts one alert to the REST endpoint, or sends an email to a secret address. my-iris creates a stateful alert instance — a Durable Object — that owns this event from signal to proof.
- 02routing
Route
The alert resolves to a receiver group and its ordered on-call list. The group also sets the language of its voice calls — so the alert is addressed correctly before it ever leaves the edge.
- 03notifying
Push
my-iris sends a push notification to the first person’s my-iris app. The push carries no alert text: the app fetches it from my-iris over an authenticated connection. Someone who has not joined the app gets the call straight away.
- 04awaiting ack
Call
If the push is not answered within the push window (5 minutes by default, configurable), my-iris calls the same person, in the group’s language. The state machine holds the timing durably, with no fragile cron chain.
- 05escalating
Escalate
No acknowledgement? my-iris moves to the next person: push first, then a call. After the last person it starts again from the top, leaving out anyone who skipped — up to 20 attempts by default.
- 06resolved
Resolve & prove
A person acknowledges in the app or presses 1 on the call, and the alert resolves. my-iris saves an end report — who was notified, who acknowledged and when — and an audit-ready record of every push, call and answer.
Two-way by design
The recipient is in control. A single tap or keypress closes the loop — and every answer is captured against the alert.
Acknowledge
Tap Acknowledge in the app, or press 1 on the call. The person owns the alert. my-iris stops escalating, records the acknowledgement, and resolves the event.
Skip
Tap Skip in the app, or press 2 on the call. my-iris moves to the next person at once, and leaves this person out of the later passes of this alert only.
No answer
The push window or the call ends without an answer, and my-iris moves on automatically — silence never stalls a critical alert.
Under the hood
Everything the escalation needs
Routing, timing and proof are first-class — configured once, enforced on every alert.
Receiver groups & ordering
Define who is on call and in what order. my-iris walks the list one person at a time, so the right person is always next in line.
A thread in every alert
Everyone the alert has reached can post and read messages on it in the my-iris app while it is active. A message never counts as an acknowledgement or a skip.
Language per receiver group
Voice calls and SMS end reports use the group’s language, one of 7 supported languages. The my-iris app itself is in English.
Timing & attempt limit
The push window is 5 minutes by default and configurable; an alert makes up to 20 attempts by default. The state is durable, so timing survives restarts and redeploys.
Answer capture
Acknowledge and skip in the app, and 1 or 2 on the call, are recorded against the alert with their time. Picking up a call is not an acknowledgement; pressing 1 is.
End report
When the alert ends, my-iris saves an end report, shown in the app and the console. By SMS, to the numbers you choose, it is a paid option.
State machine, not a chain
Why a Durable Object, not an automation chain
We ran on 26 chained automations before. They have no memory between steps, lose track of who was notified, and break silently under load. my-iris gives every alert one durable, single-threaded instance that remembers its own state — so escalation is reliable, ordered and replayable.
- Remembers who was notified
- Durable timers — no polling
- Ordered, replayable rounds
- Every step audit-logged
See an alert escalate end to end
Talk to us. We open your workspace with you, verify your company and get your people on the my-iris app. Then send a test alert and watch it escalate.