• Use Cases
  • Pricing
  • Security
  • Docs
Sign InStart free

The outbound integration layer for SaaS products: emit once, then let Meshes handle routing, retries, fan-out, and delivery history.

© Copyright 2026 Meshes, Inc. All Rights Reserved.

About
  • About
  • Security
  • Blog
  • Contact
  • FAQ
Product
  • Pricing
  • Demo
  • Integrations
  • Guides
  • Changelog
  • Status
Compare
  • All comparisons
  • Build vs buy
  • vs Paragon
  • vs Merge
  • vs n8n
  • vs Zapier
  • vs Make
Use Cases
  • All use cases
  • Embedded CRM sync
  • Per-tenant Slack
  • HMAC webhooks
  • Multi-env workspaces
  • Payment failed
  • User signup fan-out
  • Churn prevention
  • Trial expired events
Developers
  • Documentation
  • Agents
  • Tools
  • API Reference
  • MCP Server
  • llms.txt
Legal
  • Terms of Service
  • Privacy Policy
  • Acceptable Use Policy
  • Cookie Policy

Integration Engineering Blog

Patterns, product updates, and implementation guides for SaaS integrations, event routing, retries, OAuth, and reliable delivery.

Cover Image for Why per-task integration pricing breaks when your users are AI agents

Why per-task integration pricing breaks when your users are AI agents

Per-task iPaaS pricing worked when humans generated the load. AI agents do not. A teardown of why the economics break, how other pricing models fare, and the questions to ask when evaluating integration pricing that survives agent workloads.

Cover Image for Designing Event Schemas for SaaS Integrations: What to Emit, What to Skip, and How to Not Regret It Later

Designing Event Schemas for SaaS Integrations: What to Emit, What to Skip, and How to Not Regret It Later

Every SaaS integration starts with a decision most teams make too quickly: what does the event payload look like? This post covers what belongs in the payload, what to leave out, naming conventions, versioning, and the anti-patterns that cause problems in production.

Cover Image for Why Webhook Delivery Fails in Production (And What to Do About It)

Why Webhook Delivery Fails in Production (And What to Do About It)

Your webhook integration works perfectly in development. In production, failures are intermittent, silent, and context-dependent. This post covers the seven actual failure modes for outbound event delivery — and what a real fix looks like.

Cover Image for What Your Integration Code Is Missing: Delivery Guarantees for Product Events

What Your Integration Code Is Missing: Delivery Guarantees for Product Events

Your SaaS sends events to external tools, but the gap between "sends events" and "guarantees delivery" is wider than most teams realize. This post breaks down the five delivery gaps — retries, idempotency, dead letters, isolation, and visibility — and what it takes to close them.

Cover Image for Build vs Buy - The True Cost of Hand-Rolled SaaS Integrations

Build vs Buy - The True Cost of Hand-Rolled SaaS Integrations

Hand-rolled integrations look cheap until retries, dead letters, credential storage, replay tooling, and on-call load show up. A practical build-vs-buy look for SaaS teams.

Cover Image for OAuth Token Management for SaaS Integrations - The Patterns That Don't Break at 3am

OAuth Token Management for SaaS Integrations - The Patterns That Don't Break at 3am

OAuth tokens do not fail on schedule. They expire during jobs, race during refresh, and get revoked without warning. This guide covers the multi-tenant patterns that keep SaaS integrations running.

Cover Image for Idempotent Event Delivery - Why Your Webhooks Process Duplicates (And How to Stop)

Idempotent Event Delivery - Why Your Webhooks Process Duplicates (And How to Stop)

Duplicate webhook deliveries are normal in at-least-once systems. Learn idempotency keys, dedup strategies, and Node.js patterns that prevent double-processing.

Cover Image for What Is Fan-Out Architecture? Patterns, Tradeoffs, and When to Use It

What Is Fan-Out Architecture? Patterns, Tradeoffs, and When to Use It

One event in, many deliveries out — each with its own retries and failure isolation. A practical guide to fan-out architecture for SaaS integration teams.

Cover Image for How to Send Product Events to HubSpot from Your SaaS: Direct API vs Zapier vs Meshes

How to Send Product Events to HubSpot from Your SaaS: Direct API vs Zapier vs Meshes

There are three common ways to send product events like signups, upgrades, and cancellations from your SaaS to HubSpot: build the integration directly against HubSpot's API, send events through Zapier, or use an event routing layer like Meshes. Each approach has different tradeoffs in engineering effort, reliability, and long-term flexibility.

Cover Image for How to Implement Webhook Retry Logic in Node.js (And Why You Shouldn't)

How to Implement Webhook Retry Logic in Node.js (And Why You Shouldn't)

Production webhook retry logic requires exponential backoff, jitter, idempotency tracking, dead letter queues, and per-destination rate limiting — typically 1,500–3,000 lines of code before you add any destination-specific logic. This post walks through building it yourself, then explains why most SaaS teams shouldn't.

Cover Image for Why Every SaaS Needs a Dead Letter Queue (And How to Stop Losing Events)

Why Every SaaS Needs a Dead Letter Queue (And How to Stop Losing Events)

When webhooks fail and retries are exhausted, events disappear unless you have a dead letter queue. This post explains what DLQs are, how to implement them for webhooks, and why most teams get this wrong.

Cover Image for How to Keep HubSpot and Salesforce in Sync Without Building a Data Pipeline

How to Keep HubSpot and Salesforce in Sync Without Building a Data Pipeline

Syncing customer data between HubSpot and Salesforce is a rite of passage for growing SaaS teams. This post covers the common approaches, where they break, and how an event-driven integration layer avoids the mess.