Event signal:alert.triggered| Destination:Slack| Use case:Per-Tenant Slack Alerts| Typical setup:~20 minutes
Workflow outcome
The workflow starts with one alert.triggered event from your product and ends with a formatted Slack message in whichever channel each customer picked when they connected Slack from the embedded workspace UI.
Each customer authorizes Slack once inside the embed, selects a channel, and saves a rule. Your backend emits the product event with that customer's publishable key; Meshes delivers it to the workspace's Slack connection.
Why teams care
Customers usually want your product's important events in their own Slack, not yours. Meshes turns that ask into a dashboard toggle instead of another subsystem in your codebase.
Keeping Slack OAuth, channel selection, and message templates per workspace means credentials stay scoped to the customer — a revoked token in one tenant never affects another.
The same pattern covers your own dev, staging, and production workspaces: each environment authorizes its own Slack and posts to its own channel so test data stays out of real ops rooms.
This is the flagship embedded-iPaaS pattern. Once the embed is wired up, every future Slack-like integration (CRM, email, webhooks) uses the same per-workspace connection model.
What it depends on
These pages stay focused on the workflow outcome, but the setup still needs the right workspace, destination connection, and event path underneath.
Provision one Meshes workspace per customer so each tenant has its own publishable key and its own connection scope.
Read moreMount the embedded Meshes pages inside your product so customers can manage their own connections and rules without leaving your app.
Read moreMint a workspace-scoped session for the current customer on your backend before loading the embed.
Read moreConfirm Slack is enabled for your organization in Meshes so it appears in the embedded Connections page.
Read moreThe source event
Alert payloads usually carry severity, resource, and threshold context so a human can triage quickly. Keep the fields customer-facing — the workspace owner is the one reading the Slack message, not your internal team.
Event payload
alert.triggered{
"alert_id": "alrt_tyrion_42",
"account_id": "acc_casterly",
"severity": "high",
"resource": "api_latency_p95",
"value": 1840,
"threshold": 1000,
"triggered_at": "2026-04-17T16:02:00Z"
}What matters most
severity
Lets the rule filter so only alerts above the customer's chosen severity reach Slack.
resource
Identifies what crossed the threshold so the Slack message is immediately actionable.
value + threshold
Gives the customer a clear picture of how far the signal is from normal without opening another dashboard.
account_id
Helps the customer link the alert back to the record in their own tools when they want more context.
triggered_at
Lets the customer correlate the Slack message with their own monitoring timeline.
Field mapping view
| Event field | Destination target | Why it matters |
|---|---|---|
| severity | Slack message header | Emphasize high-severity alerts so the channel audience triages correctly. |
| resource | Slack message body | Tell the reader which resource crossed the threshold in plain language. |
| value + threshold | Context block | Show the delta so the reader knows how far off baseline the signal is. |
| account_id | Reference block | Give the customer a stable handle for follow-up in their own systems. |
| triggered_at | Timestamp | Keep the alert anchored in time so it is easy to cross-reference. |
The destination connection
Your customers connect Slack from the embedded Meshes workspace UI — not from your app. Mint a workspace-scoped session on your backend, mount the embed, and let the customer authorize Slack and pick a channel. The connection lives in that workspace only.
Where Meshes matters
Most teams do not need another destination. They need the destination to stay in sync without embedding its delivery quirks, retries, and mapping logic into the product code path.
Once the customer connects Slack inside their workspace, create a rule that binds alert.triggered to a Slack Send Message action. You can pre-seed a default rule when you provision a workspace so every customer starts from a working baseline they can then adjust.
A sample event
This is the part teams like: the source event stays readable and product-shaped while Meshes owns the destination-facing complexity.
TypeScript example
import MeshesEventsClient from '@mesheshq/events';
// Use the workspace publishable key that belongs to this customer.
// Your backend looks it up for the signed-in tenant before emitting.
const events = new MeshesEventsClient(tenant.meshesPublishableKey);
await events.emit({
event: 'alert.triggered',
resource: 'alert',
resource_id: 'alrt_tyrion_42',
payload: {
alert_id: 'alrt_tyrion_42',
account_id: 'acc_casterly',
severity: 'high',
resource: 'api_latency_p95',
value: 1840,
threshold: 1000,
triggered_at: '2026-04-17T16:02:00Z',
},
});Destination outcome
Ask the customer to use Send Test Event from inside the embedded workspace UI to fire a sample alert.triggered, or trigger a real event from your product using that tenant's publishable key. The Slack message should land in the customer's chosen channel within seconds.
Operational visibility
The difference between a nice demo and a usable product workflow is whether you can see what happened when the destination is slow, misconfigured, or unavailable.
In Meshes
alert.triggered event was received on the workspace.Why teams buy Meshes
What's next
Use Case
See the broader embedded-iPaaS pattern this guide implements across multiple customers.
Open linkDocs
Understand how the embedded Meshes UI mounts inside your product.
Open linkDocs
Mint workspace-scoped sessions from your backend so each customer only sees their own workspace.
Open linkDocs
See how customers authorize Slack and other OAuth connections without secrets touching your backend.
Open linkIntegration
Read the Slack connection, action, and message template details.
Open linkGuide
See the same embedded pattern applied to customer-registered webhook endpoints.
Open link