Every B2B SaaS company eventually builds a Zapier listing and calls it an integration strategy. Most of their enterprise prospects quietly move on to a competitor with a native Salesforce integration.
The problem is not that Zapier is wrong. It is that most product teams treat integrations as a checklist item rather than a sequenced strategy. You end up with 200 integrations that nobody asked for and missing the four that close deals.
This guide gives you a framework for deciding what to build, what to buy via iPaaS, and what to skip entirely — along with realistic costs for each approach.
The Integration Maturity Ladder
There are four meaningfully different levels of integration capability. Each requires different investment, different maintenance overhead, and serves a different buyer segment. Most companies should move through them sequentially, not skip ahead.
Level 1: Zapier / Make listing
Cost: $0–2K to build, $0 ongoing (platform covers hosting). Build time: 1–3 days.
A Zapier listing covers 5,000+ tools with no ongoing maintenance. It signals “we have integrations” to SMB buyers who are already Zapier users. It does not satisfy enterprise procurement teams, and it requires your customers to build and maintain their own zaps. The integration exists on paper. It is still mostly on the customer to make it work.
Build this first. It is table stakes, costs almost nothing, and unblocks a segment of buyers while you build what comes next.
Level 2: Public API with webhooks
Cost: $5K–15K to build properly, plus documentation. Build time: 2–6 weeks.
A documented REST API with webhook support lets technical buyers integrate anything. It has zero per-connection maintenance overhead once built. Developers at your customers can build exactly the integration their org needs. This is what closes technical buyers at early-stage startups and engineering-led companies.
A webhook-first API also future-proofs your integration strategy: every Level 3 native integration you build later is just a polished wrapper around the same API surface.
Level 3: Native integrations
Cost: $15K–40K each. Build time: 6–12 weeks per integration.
Native integrations are first-class integrations that your team builds and maintains: Salesforce, HubSpot, Jira, Slack, Microsoft Teams. These are the integrations that appear in 80% of enterprise procurement checklists. They require OAuth, real-time sync via webhooks, a customer-facing configuration UI, error handling visible to the customer, and sync history logs.
Do not build these before you have evidence that specific integrations are blocking deals. Prioritize based on lost deal analysis, not assumptions about what enterprise buyers want.
Level 4: iPaaS embedded
Cost: $2K–8K/month licensing, plus $20K–60K implementation. Build time: 4–12 weeks.
Tools like Merge, Paragon, and Workato Embedded let you white-label an integration layer so your customers can manage their own connections. This is the right move when you need 10+ integrations quickly, when customers need self-service configuration, and when your team does not want to maintain individual integrations. You are buying time-to-market at the cost of recurring licensing and less integration customization.
The 4 Integrations That Close Enterprise Deals
You do not need 200 integrations. You need the 4 that appear in most enterprise evaluations. Research into B2B SaaS deal loss patterns consistently points to the same categories:
| Category | Key tools | Why it matters |
|---|---|---|
| CRM | Salesforce, HubSpot | Data lives in CRM. If your app does not sync to it, adoption stalls because users have to maintain two records. |
| Ticketing | Jira, ServiceNow | Engineering and ops teams run on tickets. Creating tickets from your app is table stakes for enterprise ops use cases. |
| Identity | Okta, Azure AD | SSO/SCIM is a hard requirement for most enterprise IT teams. Without it, you cannot get through security review. |
| Communication | Slack, Microsoft Teams | Alerts and notifications in the tool teams already live in drives adoption without requiring behavior change. |
If you are missing all four, you are not making it onto enterprise shortlists. If you have one or two, focus the next integration investment on whichever of these four appears most in your lost deal notes.
Build vs Buy Decision Matrix
| Factor | Build custom | Use iPaaS |
|---|---|---|
| Maintenance ownership | You maintain, 2–4 hrs/month per integration | Provider maintains connector layer, you maintain config |
| Time to market | 6–12 weeks per integration | Days to weeks once iPaaS is implemented |
| Customization depth | Full control over data model and logic | Limited to provider data model and workflow options |
| Customer self-service | Must build configuration UI yourself | White-labeled customer UI included |
| Long-term cost | Lower at scale, no recurring licensing | $24K–96K/year recurring, scales with usage |
The decision is usually not build vs buy across the board. It is: build your top 2–3 integrations natively (the ones that appear in 80% of evaluations), and use iPaaS to cover the long tail quickly once you have evidence there is demand.
What a Native Salesforce Integration Actually Involves
Most product managers underestimate this build. A native Salesforce integration is not a one-way sync. Here is what the full scope looks like for a production-quality integration:
- OAuth 2.0 flow — your customers authorize your app to access their Salesforce org without sharing credentials. Requires Salesforce Connected App setup on your side and a callback URL flow.
- Webhooks for real-time sync — Salesforce Push Topic or Change Data Capture (CDC) notifies your app when records change. This is what makes the integration feel live rather than batched.
- Field mapping UI — the screen where your customers configure which Salesforce fields map to your fields. This is not optional for enterprise buyers. Without it, every customer configuration requires a support ticket or professional services engagement. This component alone accounts for 30–40% of the build.
- Conflict resolution — what happens when the same record is updated in both systems before sync runs. Most integrations paper over this. Good ones surface conflicts explicitly.
- Sync history and logs — a visible log of what synced, when, and what failed. Your support team needs this to debug customer reports. Enterprise buyers often ask to see it during evaluation.
- Error handling with user-visible status — when a sync fails, your customers need to know why and what to do, not just that “sync failed.”
Not a weekend project. Budget 6–10 weeks and $15K–40K. The lower end applies to simple one-way syncs; the higher end to bi-directional sync with field mapping UI and conflict resolution.
iPaaS Options Compared
| Platform | Model | Monthly cost | Best for |
|---|---|---|---|
| Merge.dev | Unified API — one API for each category (CRM, ATS, etc.) | $650–2K | Fastest time to market, standard data models |
| Paragon | White-labeled workflow builder for your customers | $2K–8K | Customer self-service, Zapier-like inside your product |
| Workato Embedded | Enterprise-grade workflow automation, white-labeled | $4K–15K | Complex enterprise workflows, compliance-heavy buyers |
| Build custom | Native integration you own and maintain | $0 recurring (one-time $15K–40K+) | Differentiated logic, high-volume, no licensing ceiling |
Common Mistakes
Building integrations before customers ask for them. Every integration you build is a surface you maintain forever. Build integrations that appear in lost deal notes, not ones you think enterprise buyers might want.
Building Salesforce before HubSpot. HubSpot is more common in the SMB and mid-market where most B2B SaaS companies actually start. If your current customer base skews SMB, HubSpot often has a larger footprint than Salesforce. Check your customer records before assuming which CRM to build first.
Not building a field mapping UI. This is the single most common reason integration complaints end up in support. Without self-service field mapping, every customer with a non-standard Salesforce configuration needs a professional services engagement to get set up. The UI takes 30–40% of the build time but saves a disproportionate amount of support overhead.
Ignoring webhook delivery failures. Integrations that fail silently are worse than integrations that do not exist. A customer who thinks their data is syncing when it is not will churn angry and confused. Build delivery confirmation, retry logic, and visible error states into every integration from the start.
Frequently Asked Questions
Should I build integrations before or after product-market fit?
After. Pre-PMF, a Zapier listing plus a public API is enough to unblock technical buyers. Native integrations belong on the roadmap when specific integrations start appearing in 20% or more of your lost deal notes. Building Salesforce integration before you have 20 Salesforce users in your pipeline is building for the company you hope to be, not the one you are.
How much does it cost to build a native Salesforce integration?
A well-built Salesforce integration with OAuth, webhooks, field mapping UI, and error handling runs $15K–40K. Timeline is 6–10 weeks for a developer who knows the Salesforce API. Factor in 2–4 hours per month of ongoing maintenance. The field mapping UI alone accounts for 30–40% of the build cost, but without it every configuration requires a support ticket.
What is iPaaS and should we use it?
iPaaS (Integration Platform as a Service) tools like Merge, Paragon, or Workato Embedded let you offer many integrations without building each one. Good fit when: you need 10 or more integrations quickly, your customers need self-service configuration, and you can absorb $2K–8K per month in licensing. Not a fit when you need deeply customized integration logic or when your integration requirements are simple enough that a few native builds cover 80% of requests.
Our enterprise prospect is asking for a Jira integration. How fast can we ship it?
A basic read/write Jira integration (create issues, update status, sync comments) takes 2–4 weeks for a developer who knows the Atlassian API. A polished integration with field mapping, bi-directional sync, and a customer-facing configuration UI is 6–8 weeks. If you need to ship in two weeks, scope to write-only first (create Jira issues from your app), then add bi-directional sync in a second phase.
