What is Meshes?

Meshes is the outbound integration layer for SaaS products.

Your app emits product events once. Meshes routes those events to the right customer-facing destinations: CRMs, email tools, support platforms, webhooks, and other downstream systems.

Instead of building and maintaining a separate delivery path for every integration, you get one consistent system for:

• routing events to one or many destinations
• managing customer-specific connections and credentials
• retrying failed deliveries automatically
• inspecting failures and replaying when needed
• isolating every customer or environment in its own workspace

What Meshes Is For

Meshes is a good fit when your product needs to send events like:

• contact.created
• trial.started
• invoice.paid
• subscription.canceled

to tools like:

• HubSpot
• Salesforce
• Intercom
• Mailchimp
• Slack
• webhooks

The pattern is:

1. your app emits an event
2. Meshes evaluates the rules for that workspace
3. Meshes fans the event out to the configured destinations
4. Meshes handles retries, failures, and delivery history

What Meshes Replaces

Without Meshes, most teams end up maintaining some version of this:

• destination-specific webhook handlers
• queue workers for each integration path
• retry logic scattered across services
• credential plumbing for each customer connection
• fragmented logs and ad-hoc debugging tools

Meshes consolidates that into a shared delivery layer.

High-Level Flow

1. Your app emits an event

{
  "event": "contact.created",
  "payload": {
    "id": "contact_123",
    "email": "jane@example.com",
    "source": "marketing-site",
    "tier": "starter"
  }
}

2. Meshes evaluates the rules for that event

For example:

• send to HubSpot
• send to Mailchimp
• send to an internal webhook

3. Meshes delivers with built-in reliability

That includes:

• fan-out to multiple destinations
• retries with backoff for transient failures
• failure details in the UI
• replay when you need to retry intentionally

4. You inspect everything in one place

You can review:

• event history
• per-destination delivery status
• failures and retries
• dead letters and replay paths

What Meshes Is Not

Meshes is not primarily a no-code internal workflow builder.

It is built for product integration infrastructure:

• customer-facing integrations
• workspace-scoped credentials
• reliable event delivery
• operational visibility across destinations

If all you need is a single direct webhook to one internal service, you may not need Meshes yet. Once you are dealing with multiple destinations, customer-owned connections, retries, and failure handling, Meshes becomes much more valuable.

Best Way to Evaluate It

The fastest way to understand Meshes is to use it in the dashboard first:

1. create a workspace
2. connect a webhook
3. create a rule
4. click Send Test Event
5. inspect the event in Events

Then, once the flow is working, wire your app to Meshes with a publishable key or server-side JWT depending on your environment.