What is Meshes?

Meshes is a developer-first integration layer for your SaaS.

You send events from your product. Meshes applies rules you define and delivers those events to the right destinations: CRMs, email tools, webhooks, internal services, and more.

Instead of building and maintaining a web of one-off integrations, queues, and retry logic, you get a single, reliable spine for all your integrations:

• Events in → fan-out out to any number of destinations
• Rules decide where each event goes
• Retries & backoff handle flaky or rate-limited APIs
• Workspaces give you clean multi-tenant isolation

Why Meshes?

Typical integration work looks like this:

• Custom handlers for each webhook
• Per-integration queues and workers
• Cron jobs to retry failures
• Ad-hoc logging and dashboards
• Every new integration = a new pile of glue code

Meshes replaces that glue with a consistent model:

1. Describe the event (lead.created, invoice.paid, etc.)
2. Define rules for what should happen when that event occurs
3. Connect destinations (HubSpot, Salesforce, Mailchimp, webhooks, etc.)
4. Emit events from your app
5. Meshes routes, retries, and tracks everything for you

High-Level Flow

1. Your app emits an event

{
  "type": "lead.created",
  "workspace": "acme-prod",
  "payload": {
    "id": "lead_123",
    "email": "jane@example.com",
    "source": "marketing-site",
    "plan": "starter",
  },
}

2. Meshes evaluates rules for lead.created in that workspace:

• Send to HubSpot as a contact
• Enqueue a webhook to your internal service
• Add to Mailchimp or another email provider

3. Fan-out delivery happens in parallel with built-in reliability:

• Automatic retries with backoff
• Respect for third-party rate limits
• Dead-letter capture when destinations stay broken

4. You observe and debug in one place

• Per-event timeline
• Per-destination status
• Error messages and replay tools

When to Use Meshes

Meshes is a good fit when:

• You need to integrate with multiple external systems (CRMs, marketing tools, internal services).
• You support many customers and don’t want per-tenant integration snowflakes.
• You want multi-tenant isolation of credentials, traffic, and audit history.
• You care about reliability (retries, dead letters) but don’t want to build queues and workers yourself.
• You plan to resell integrations to your customers and need a clean way to manage them at scale.

If you just want a single webhook to a single internal service, direct HTTP calls might be fine. Once you’re dealing with multiple destinations, tenants, and failure modes, Meshes takes over the undifferentiated heavy lifting.