Event:subscription.cancelled· Destinations:IntercomSalesforceSlack
The problem
A cancellation signal trapped in your billing system is too late by the time it reaches the workspace owner manually. RevOps wants the revenue context in their CRM, support wants the reason in their messaging tool, and ops wants the signal in their Slack fast enough to start offboarding or a win-back flow — and every tenant wants it in their own stack.
Teams usually patch this together with one CRM webhook, one Slack notifier, and one internal job that writes data somewhere later. The result is inconsistent timing and conflicting data across tools in every workspace, right when the account is most at risk.
If the cancellation event fails to reach one destination in one workspace, that tenant's record stays stale, the alert never lands, and their churn analysis has holes in it. Delivery guarantees belong in the event layer, not in your app.
The event flow
Meshes receives the source event once, maps it to the right destinations per workspace, and keeps delivery visible when downstream APIs fail.
Event payload
subscription.cancelled{
"customer_id": "cus_5501",
"subscription_id": "sub_5501",
"email": "sam@bluebird.app",
"plan": "pro",
"reason": "missing_salesforce_sync",
"cancellation_date": "2026-03-20",
"mrr_lost": 249,
"tenure_months": 14
}Meshes tags the user via the workspace's Intercom connection so win-back or offboarding sequences can branch on cancellation state.
Lifecycle messaging in each workspace starts from the real cancellation event instead of an export or support note.
Meshes updates cancellation reason, MRR impact, and date fields using the workspace's Salesforce credentials and mapping.
Whoever owns CS or RevOps inside that tenant can prioritize outreach and analyze churn with current revenue context.
Meshes sends a structured alert to the channel the workspace owner picked, with plan, reason, tenure, and MRR lost.
Each workspace sees churn signals in its own channel in real time instead of waiting for a report.
How Meshes handles it
Instead of maintaining separate workers, retry logic, and visibility per destination, Meshes gives you one event path, destination-aware routing, and built-in delivery guarantees.
From your product
subscription.cancelledenters Meshes onceimport MeshesEventsClient from '@mesheshq/events';
const meshes = new MeshesEventsClient(
process.env.WORKSPACE_PUBLISHABLE_KEY!,
);
await meshes.emit({
event: 'subscription.cancelled',
resource: 'subscription_plan',
resource_id: 'pro',
payload: {
customer_id: 'cus_5501',
subscription_id: 'sub_5501',
email: 'sam@bluebird.app',
plan: 'pro',
reason: 'missing_salesforce_sync',
cancellation_date: '2026-03-20',
mrr_lost: 249,
tenure_months: 14,
},
});Across destinations
On every delivery
Why this matters
If the right team sees the cancellation immediately, they have a chance to recover the account or at least capture the reason while the context is still fresh.
Slack wants a human alert, Salesforce wants structured revenue fields, and Intercom wants segmentation. Routing one event cleanly keeps those views consistent inside each workspace.
Cancellation routing should not be a black box. Meshes makes it clear per workspace which downstream system received the signal and which one needs attention.
Related
Docs
See the same event-routing pattern behind this cancellation workflow.
Open linkDocs
See how Meshes routes one cancellation signal into every workspace it applies to.
Open linkIntegration
Apply tags so lifecycle and support messaging can react to churn signals in each workspace.
Open linkIntegration
Update revenue and cancellation context using each workspace's own Salesforce credentials.
Open linkIntegration
Send churn alerts directly into whichever channel each workspace monitors.
Open linkBlog
See how cancellation signals can route to different destinations based on the event itself.
Open linkCompare
Compare observable churn routing with maintaining cancellation workers and queue logic yourself across tenants.
Open linksubscription.cancelled through Meshes once and let every workspace — tenant or environment — keep its CS, RevOps, and lifecycle systems working from the same churn signal.