Skip to content
OpenNow accepting new client engagements
All posts
Guide6 min read

Connecting your business systems without replacing them

Your CRM, billing, product, and support tools don't talk to each other. You don't need to rip any of them out. Integration patterns, sync strategies, and when to use iPaaS versus a custom build.

mrkd teamOctober 20, 2026

Most SaaS companies run on ten to thirty tools. A CRM, a billing system, the product database, a support desk, a marketing platform, a data warehouse, Slack. Each one is fine on its own. Together, they disagree about almost everything.

The CRM thinks a customer is on the Pro plan. Billing says they downgraded last week. Support has an old email address. The product knows they haven't logged in for a month, and nobody else does.

The tempting fix is a big platform that does it all. Replace the CRM, consolidate billing, move support into the same suite. Sometimes that's right. Usually it's a twelve-month migration that trades one set of problems for another, and your team loses tools they actually like.

There's a better default: keep the systems, connect them properly. This guide covers how.

Start with the questions, not the connectors

Before picking a tool, map what needs to move and why. For each connection, answer:

  • What data? Customers, accounts, subscriptions, invoices, tickets, product events.
  • Which direction? One way, or both?
  • Which system is the source of truth? For each field, one system wins. If you can't name it, you'll get loops and overwrites.
  • How fresh does it need to be? Within seconds, within an hour, or by tomorrow morning?
  • What happens when it fails? Who finds out, and how?

That last question is the one most teams skip. Every integration fails sometimes. An API goes down. A field changes type. A rate limit kicks in. The difference between a good integration and a bad one is whether anyone notices.

The four sync patterns

Almost every integration is one of these, or a combination.

1. Event-driven (webhooks). When something happens in system A, it notifies system B right away. A subscription changes in Stripe, a webhook fires, the CRM updates. Fast and efficient. The catch: you need to handle missed events, duplicates, and events arriving out of order.

2. Scheduled sync (polling). Every few minutes or hours, a job asks system A what changed and pushes updates to B. Simpler to reason about and easier to recover from failures. The catch: data is only as fresh as the schedule, and polling large datasets can hit rate limits.

3. Hub and spoke. Instead of connecting every tool to every other tool, everything flows through one central place, often a data warehouse or a small integration service you own. Each system connects once. This scales far better than point-to-point once you pass five or six tools.

4. Reverse ETL. Data is modeled in the warehouse, then pushed back out to operational tools. Your warehouse calculates a health score, and it appears on the account in the CRM and the support desk. Good for derived data that no single system owns.

Most mature setups use event-driven sync for the things that need to be fast, like plan changes and new signups, and scheduled or warehouse-based sync for everything else.

iPaaS versus a custom build

iPaaS means integration platform as a service: Zapier, Make, Workato, Tray, n8n, and the native sync features inside tools like HubSpot. They're excellent, and they're where most companies should start.

When iPaaS is the right call

  • The tools have good prebuilt connectors. Mainstream SaaS to mainstream SaaS.
  • The logic is simple. When X happens, create or update Y. A few filters, a little formatting.
  • Volume is moderate. Hundreds or low thousands of events a day.
  • A non-engineer needs to own it. Ops and marketing teams can maintain these flows themselves.
  • You need it this week. Nothing beats iPaaS for speed to first working version.

When custom wins

  • You're connecting to your own product. Your app's database and APIs rarely have a prebuilt connector, and the logic is specific to your business.
  • The logic is complex. Multi-step transformations, matching records across systems, deduplication, branching rules. Visual builders get unreadable fast when the flow has forty steps.
  • Volume is high. Per-task pricing that was cheap at a thousand events a day gets expensive at a million.
  • Reliability really matters. You need retries, idempotency, dead-letter queues, alerting, and logs you can actually search. Some platforms offer parts of this. A custom service gives you all of it.
  • Security or compliance requires it. Customer data passing through a third-party platform may not be acceptable for your contracts or your customers' security reviews.
  • The flows are core to the business. If revenue depends on it, you want it in version control, tested, and reviewed like the rest of your code.

The hybrid most teams end up with

In practice, it's rarely either-or. We often see a small custom integration service handling the core flows (product to billing to CRM) with proper monitoring, while ops teams use iPaaS for the long tail of lighter automations. Both are fine. The mistake is running revenue-critical sync through a forty-step Zap nobody can debug.

Where AI fits

AI is useful in integration work in a few specific places. It's not a replacement for good plumbing.

  • Matching messy records. Is "Acme Inc" in the CRM the same company as "ACME Corporation" in billing? Models are good at fuzzy matching, with a human reviewing low-confidence cases.
  • Extracting structure from unstructured input. Turning emails, PDFs, or support tickets into fields another system can use.
  • Routing and classification. Tagging inbound requests and sending them to the right queue or system.
  • Summaries across systems. Pulling the CRM, billing, and support history for an account into a short brief before a renewal call.

Keep AI on the steps where judgment helps, and keep deterministic code on the steps where it doesn't. Moving a payment status from billing to the CRM is not a job for a language model.

Building integrations that last

Whether you use iPaaS or custom code, the same habits keep integrations healthy.

  • Make every operation safe to retry. If the same event arrives twice, the result should be the same.
  • Log every sync. What moved, when, and what happened. When a field looks wrong, you can trace it.
  • Alert on failure, and on silence. A sync that errors is easy to spot. A sync that quietly stopped running three weeks ago is not.
  • Version your mappings. When a field changes in one system, you need to know which integrations break.
  • Name an owner. Every integration needs a person who gets the alert and knows how to fix it.

When it is time to replace a system

Sometimes connecting isn't enough. Replace a system when the integration cost is higher than the switching cost, when the tool can't expose the data you need through any API, or when two tools overlap so much that keeping both is pure waste. If you find yourself building a custom tool to cover gaps the current ones can't, we cover that decision in build vs buy: when a custom web app beats off-the-shelf SaaS. And if the system that needs replacing is a spreadsheet, start with replacing spreadsheets with a custom web app.

Most of the time, though, the tools are fine. It's the gaps between them that hurt.

The short version

Don't replace systems that work. Map what moves where, name a source of truth for each field, and pick the right sync pattern for each flow. Start with iPaaS for simple, low-volume connections. Build custom when the flow touches your product, carries real volume, or keeps revenue running. Use AI for matching and classification, not for moving money.

If your systems are disagreeing with each other and your team is filling the gaps by hand, send us a short brief. See how we build integrations and internal tools on our web app development page, and how we apply AI to operations work on our AI solutions page. We reply within one business day.

Let's build something

Need a partner like us?

Tell us about your project. We respond within one business day.