Response
Workflows
Build automated incident response workflows with a visual flow builder. Connect triggers, processing nodes, and notification destinations to create powerful automation pipelines.
Overview
Workflows are the heart of alerting and automation in Uptimy. When a monitored failure creates an incident, workflows take over and handle everything that happens next: where notifications go, how messages are formatted and which teams get paged. You build all of this with a visual drag-and-drop flow builder.
Workflows run on incidents that monitors open: failed healthchecks, missed heartbeats, Railway, Render and Vercel deploy events, and outages of the services you follow. Each monitor's incident conditions decide when it counts as down or degraded. Once an incident opens, matching workflows run your predefined response steps to notify the right people. Reporting an incident by hand, or changing an incident's status by hand, runs no workflows.
Each workflow is a directed graph of nodes connected by edges. Data flows from a trigger node through optional processing nodes (filters, delays, deduplication, on-call lookups) and terminates at one or more destination nodes (Slack, PagerDuty, email, webhooks, and more).
Conditions + Workflows = Complete Alerting
Detection decides when to create an incident. Workflows decide what happens after. This clean separation means you can change your notification routing, add new destinations, or tweak message templates without touching your detection logic.
Workflow Templates
To get started quickly, the flow builder's Templates tab has pre-built workflows: Service down alert, Smart escalation and Deduplicated PagerDuty. Three more hand new incidents to your own AI agent: Slack: AI handover, GitHub issue for your coding agent and Webhook: start an agent run; see AI Handover. Pick a template and customize it to fit your needs.
Node Categories
The flow builder organizes nodes into three categories: triggers that start the workflow, processing nodes that filter, delay and shape the data, and destination nodes that deliver notifications and alerts.
Trigger Nodes (Entry Points)
Every workflow begins with exactly one trigger node. In it you switch on the incident events the workflow runs for, one or more of these:
| Event | Description |
|---|---|
| Incident created | Fires when a monitor opens a new incident: a monitor going down, a missed heartbeat, a degraded monitor that alerts, a failed Railway or Render deploy. Also fires again when an open incident gets worse, such as a degraded monitor going down, so every workflow that pages on new outages pages on this one too. |
| Incident updated | Fires in two cases only. A monitor fails again within 5 minutes of its incident resolving, so the same incident re-opens (a re-open that's worse than before, degraded then down, fires Incident created instead). Or a Railway or Render service crashes 3 times within 10 minutes, which raises its incident to critical. Status changes and updates posted by people don't fire it. |
| Incident resolved | Fires when a monitor recovers and resolves its incident. Use this to send recovery notifications and close the loop with your team. |
Monitor events are what open and resolve incidents: healthchecks going down or recovering, heartbeats missed or back on time, Railway deploys crashing, failing or succeeding, Render services and deploys failing or recovering, Vercel production deploys failing or succeeding, and outages of services you follow. A Filter node after the trigger narrows which incidents continue by source, severity, tags, and specific monitors.
Filtering by Tags
Use a Filter node to scope a workflow to what matters. For example, continue only for incidents opened by healthchecks or heartbeats tagged production, so staging and development don't page anyone. An incident passes when its monitor has any of the chosen tags; untagged monitors don't.
Processing Nodes (Middle)
Processing nodes sit between the trigger and destinations. They let you add logic, delays, deduplication and on-call lookups to your workflow. You can chain multiple processing nodes together.
| Node | Description |
|---|---|
| Filter | Filter the workflow based on severity levels, specific monitors, sources, tags, or event types. Each criterion you set must match; within tags, any one of them is enough. Optionally check whether the incident is still active before proceeding. |
| Delay | Wait a specified duration or until a specific time of day before continuing. Useful for escalation chains where you want to give the on-call engineer time to respond. |
| Deduplicate | Let the first event for a monitor through and drop repeats for the same monitor at the same severity until the suppression window ends (1 minute, 5 minutes, 15 minutes, 1 hour, or a custom number of seconds). Quiets a flapping monitor. A recovery, or a degraded monitor going down, still gets through. |
| Refresh incident | Re-read the incident's current state, so every step after it can use {{variables.incident.*}} (title, status, severity, error message, start and resolve times). Most useful after a Delay, so later steps act on the latest status. |
| On-call | Find who is on call right now in one of your on-call schedules and pass their name, email and phone to later steps. Email, SMS and WhatsApp can send to them directly. A participant offset of 1 picks the next person in the rotation, for escalation. |
| Update incident | Set the incident's title, description (the text your status pages show) or severity, and publish it to the status pages you pick. Publishing tells those pages' subscribers. It doesn't change the incident's status. |
Example: Escalation Chain
A common pattern is to notify a Slack channel immediately, then add a Delay node set to 10 minutes. After the delay, add a Filter node that checks whether the incident is still active. If it is, route to PagerDuty for escalation. Build this visually by dragging nodes onto the canvas and connecting them with edges.
Destination Nodes
Destination nodes deliver notifications and data to external services. Each workflow can have multiple destinations, and you can use Filter nodes to route different alerts to different channels based on severity, source, or tags.
Slack
Post to a Slack channel. Connect the channel under Integrations in one of two ways: paste an incoming webhook URL from a Slack app (api.slack.com/apps → Incoming Webhooks), or choose connect with Slack and pick the channel there. The message is a Handlebars template in Slack's formatting (*bold*, _italics_, links).
Discord
Post to a Discord channel or thread. Paste the channel's webhook URL (channel settings → Integrations → Webhooks → Copy Webhook URL), or connect with Discord and pick the channel there. The message is a Handlebars template in Discord's Markdown, cut to Discord's 2,000-character limit.
Telegram
Send messages to a Telegram chat or channel through your own bot: create one with @BotFather, add it to the chat, and connect it with its token and the chat ID. Message templates support Handlebars variables from the workflow payload.
X, Bluesky and Mastodon
One node per network publishes incident updates to a social account. Connect the account under Integrations, then pick it in the node. The message is a Handlebars template, trimmed to the network's limit (280 characters on X, 300 on Bluesky, 500 on Mastodon) with a trailing link kept intact so the linked page unfurls into its card. Typical use: a public account that posts when a service goes down and again when it recovers, so followers learn about an outage before the vendor acknowledges it.
Send an email to one or more addresses, or to whoever an On-call step found (Add on-call). The subject line and message content are Handlebars templates. The message is plain text, sent in Uptimy's email layout from noreply@upti.my.
Teams
Post to a Teams channel through its Workflows webhook: in the channel open ⋯ → Workflows → Send webhook alerts to a channel, then paste the URL it gives you under Integrations. Each message arrives as an Adaptive Card, with **bold**, _italics_ and links from the Handlebars template.
PagerDuty
Trigger a PagerDuty alert through the Events API v2. Add a token with your service's Integration Key (PagerDuty → Services → your service → Integrations → Events API v2), then pick a severity (critical, error, warning or info), a source and a message template. When the incident resolves, Uptimy resolves the PagerDuty alert too.
Send a WhatsApp message to one or more phone numbers, or to whoever an On-call step found. Growth and above.
Linear
Create Linear issues from incidents. Configure the target team and use Handlebars templates for the issue title and description, so every incident lands in your backlog with full context.
GitHub Issue
Open GitHub issues automatically in a repository of your choice. Issue title and body support Handlebars templates, making it easy to track incidents alongside your code.
Railway self-heal
Restart or redeploy a Railway service when an incident fires. Connect the project with a Railway project token, pick the service, and set the guardrails that stop a flapping service from restarting in a loop. See Connect Railway to Uptimy Cloud. Growth and above.
Render self-heal
Restart a Render service when an incident fires, with the same guardrails. Only services imported from Render can be restarted, since a Render API key sees the whole account. See Connect Render to Uptimy Cloud. Growth and above.
Vercel recovery
Redeploy a Vercel project's previous production version when an incident fires, with the same guardrails. Only projects imported from Vercel can be recovered. See Connect Vercel to Uptimy Cloud. Growth and above.
SMS
Send an SMS to one or more phone numbers, or to whoever an On-call step found. Growth and above. Ideal for reaching on-call engineers who may not be at their desk.
Webhook
Send HTTP requests to any URL. Configure the HTTP method (POST, PUT or PATCH), custom headers, and a JSON body template. This is the most flexible destination, allowing you to integrate with any service that has an HTTP API. Values in a JSON body template are escaped as they're filled in, so text with quotes or line breaks (an incident title, the AI handover prompt) still arrives as valid JSON. Slack, Discord and Teams webhook URLs go in their own nodes instead: those apps only accept their own message format.
Handlebars Templates
All destination nodes support Handlebars templating with helpers like if, unless, each, with, eq, ne, gt, and lt. Available variables include the incident as event.* (title, severity, status, errorMessage, errorClass, regions, startedAt, and handoverPrompt, the AI Handover prompt), the refreshed incident as variables.incident.*, variables.onCall.*, and timestamp.
Testing a Workflow
The Test button in the flow builder runs the workflow now, even if it's disabled, exactly as a real incident would: messages are sent, Railway actions run and delays wait. You pick the event type, the source and optionally the monitor the sample incident is named after. The sample incident isn't a real one, so Update incident has nothing to change. Templates can check {{event.test}} to tell a test from a real incident.
Workflow Run History
Every workflow execution is recorded on the workflow's Runs tab for 14 days. Each run shows the incident it ran for and what it did: Succeeded (something was sent or changed), Skipped (a filter or deduplication stopped every branch, so nothing was sent) or Failed. Open a run to see each step by its node's name, what it did, how long it took and any error. Steps after a delay are added to the same run when the delay ends.
On-Call Schedules
Create on-call schedules in Settings → On-call. A schedule has a timezone and one or more rotations; each rotation is daily or weekly, with a start date, a handoff time, its participants, and optional restrictions. The On-call node finds the current on-call person when the workflow runs, so destinations always notify the right engineer. For escalation, chain Delay nodes and On-call nodes with increasing participant offsets: the primary first, the next person in the rotation if it's still open.
Best Practices
- Start simple. Build a single trigger-to-destination workflow before adding processing nodes.
- Use the Deduplicate node to quiet a flapping monitor.
- Use the Test button before relying on a workflow for live alerts. It sends for real, so warn the channels it posts to.
- Use Filter nodes to route critical alerts to PagerDuty and low-severity alerts to Slack.
- Keep escalation delays reasonable. A 5 to 15 minute delay before escalation gives on-call engineers time to respond.
- Review workflow run history regularly to identify failures or misconfigured nodes.
- Use workflow templates as starting points rather than building from scratch.
Workflows on each plan
Every plan can build workflows, from scratch or from a template. The SMS, WhatsApp, Railway, Render and Vercel steps come with Growth and above. Check the pricing page for current plans.