Discuss your task

Search

Start typing to search articles, cases, and services.

↑↓ navigate Esc close

CRM integration that doesn't break after a month

CRM integration is the automatic exchange of data between your CRM and the other systems in your company: website, telephony, billing, messengers, ad accounts. There are three ways to build it: a ready-made marketplace app, a connector such as Zapier, Make or n8n, or custom development via API. The right approach is determined not by budget or habit, but by the direction of sync, the data volume and the cost of a single error.

Exceltic.dev builds custom integrations for Kommo and HubSpot, and most clients don’t come to us with a blank slate. Usually an integration already exists and “sort of works”: a Make scenario a marketer built two years ago, a native app switched on during the CRM rollout, and a script on a server written by a developer who left long ago.

Problems in these setups are almost never visible at configuration time. They surface months later - as volume grows, after a field is renamed, or when someone turns on a second sync running in the opposite direction. Below we cover the three integration methods, how to choose between them, the typical failures, and what goes into an integration you don’t have to fix every quarter.

In practice it looks like this. A manager copies data from a form or messenger into the record by hand, because the automatic transfer loses half the fields. Revenue from closed deals in the CRM doesn’t match billing, and the CFO stops trusting the reports.

The database holds three records for the same customer, and the integration that “was working” stopped three weeks ago - and nobody noticed, because there was nobody to show the errors to.

CRM integration: automated transfer of data between a CRM and another system according to predefined rules - which objects and fields are transferred, in which direction, on which event, and what happens on error.

The integration is responsible for data getting into and out of the CRM correctly. What happens to it next - routing leads, creating tasks, monitoring response times - is process automation inside the CRM, and we cover it in a separate article.

Three ways to connect your CRM to other systems

Any connection between a CRM and an external system falls into one of three types, and each has its own zone where it works well. The mistake is usually not the method itself, but applying it to a task of the wrong class.

Native marketplace app

A native integration is a ready-made app that the CRM vendor or the other system’s vendor publishes in a marketplace, and you enable it in a few clicks. For email, calendar, popular telephony and standard forms it is often the best choice: the vendor takes care of support, API updates and limits.

There is one limitation, but a significant one: you don’t define the logic. The field set is fixed, sync conditions can only be changed through the settings the app developer provided, and there may be no detailed error log at all. We broke down an example where a ready-made solution covers the task only partially in our article on the HubSpot and Stripe integration.

Zapier, Make and n8n connectors

No-code iPaaS-style connectors link thousands of services using an “event in one system -> action in another” pattern. A scenario takes an hour to build, and someone without programming skills can change it.

Each of them prices usage differently, and at volume that matters. As of Q4 2026, Zapier charges a task for every successful action (the trigger itself doesn’t consume tasks): the free plan gives you 100 tasks a month, and the Professional plan with 750 tasks a month starts at $19.99 per month billed annually.

Make counts credits: most module actions cost one credit, and when credits run out, scenarios stop until you top up. n8n Cloud bills per workflow execution regardless of the number of steps (from 20 euros per month for 2,500 executions billed annually), and it is also available as a self-hosted version on your own server.

The weak spots are similar across all three. Each event is processed separately, duplicate control has to be built by hand, and complex logic turns into branching scenarios that only their author understands. Retries after a temporary failure exist (on Zapier’s paid plans this is the Autoreplay feature), but you still have to design duplicate protection on retry yourself.

We covered how to choose between the three builders for Kommo in a separate comparison of Zapier, Make and n8n.

Custom API integration

A custom integration is code that works directly with the APIs of both systems, usually through a middleware service with an event queue. You define which fields are written and in what order, what counts as a duplicate, how errors are handled and who gets alerts.

The downsides are real too: higher upfront cost, plus you need hosting and someone to maintain the code after launch. If the task is to send new leads from a form to the CRM once a day, custom development is overkill. It pays off where an error costs money or where volume runs into API limits.

How to choose the right approach for your task

It’s easier to choose an integration method not by feature lists, but by six criteria that determine whether the integration will handle your volume. Go through the table and see which column most of your answers fall into.

CriterionNative appZapier, Make, n8nCustom development
DirectionAs the vendor designed it, usually one-wayOne-way is easy, two-way risks loopsAny, with explicit priority rules
Volume and API limitsHandled by the vendorEach event is a separate runBatch requests, queue, rate control
Field mappingFixed setUp to two dozen fields without complex relationshipsCustom fields, object associations, line items
Cost of an errorLow or mediumLowHigh: money, invoices, management reporting
Who maintains itApp vendorScenario authorContractor under agreement or your own team
Cost at volumeSubscription or flat feeGrows with the number of tasks, credits or executionsOne-time development plus maintenance and hosting

API limits deserve a separate check, because hitting them is a common cause of silent data loss as you grow. As of Q4 2026, Kommo limits its API to seven requests per second, and a single request can create or update no more than 250 entities (up to 50 recommended). In HubSpot, a private app gets 100 to 190 requests per 10 seconds and 250,000 to 1 million requests per day per account depending on the plan, while a public marketplace app gets 110 requests per 10 seconds per account.

Here is the practical rule from our projects. If data flows one way, there are fewer than two dozen fields, and an error can be fixed by hand in a minute, go with a native app or a connector. If the sync is two-way, involves money or documents, and there are thousands of events a day, it’s a job for a custom integration built for your stack.

Where CRM integration breaks most often

Most integration failures don’t look like an outage: everything runs, the data just gradually drifts apart. Below are the six scenarios we see most often, and none of them is visible at setup time.

Duplicates

A duplicate appears when the same event is processed twice or when the integration fails to find an existing record. Redelivery is standard behavior in many systems: for example, HubSpot retries a webhook up to 10 times over 24 hours if your server responded with an error or didn’t respond within 5 seconds. If the handler doesn’t check whether it has seen the event before, a slow response turns into a second contact or a second deal.

Loops in two-way sync

A loop occurs when system A updates a record in system B, B reports the change back, and A writes the same thing again. At best that means extra requests and a burned API limit; at worst, endless rewriting where two values take turns overwriting each other. Without an explicit rule on which system is the master for each field, two-way sync almost inevitably ends up in a loop.

Hitting limits and silent losses

When a limit is exceeded, the API returns a 429 error, and what happens next depends on the integration. If the request is simply dropped, the event is lost for good. In Kommo, repeated limit violations lead to an IP address block, after which every request gets a 403 response - meaning the entire integration stops, not just one record.

Deletions and merges don’t come through

In the integrations we audit, record creation and updates are almost always transferred, but deletions and duplicate merges rarely are. A manager merges two customer records in the CRM, while billing keeps referencing an ID that no longer exists. A month later the next billing event creates the customer again, and the duplicate is back.

Mismatched types and formats

Fields with the same name in two systems often store data differently. A date without a time zone turns into yesterday’s date, an amount with a comma instead of a decimal point becomes zero, and a dropdown value that doesn’t exist in the other system is silently dropped. Currency is a separate story: if an amount is sent without a currency code, the revenue report adds euros to dollars.

Partial failures without a log

Many operations consist of several steps: create a contact, create a deal, associate them, add line items. If the third step fails, the first two are already done, and the CRM is left with a deal without a contact. Without a log at the level of every step, you learn about such a failure from a manager who couldn’t find the customer, or from accounting at month-end close.

What a reliable integration is built from

A reliable integration differs from a fragile one not in the programming language, but in the set of safeguards that cover the failures above. Each one is simple on its own; together they give you an integration whose failures you learn about before your customers do.

  1. A source of truth for every field. You decide in advance which system is the master: the payment amount lives in billing, the deal stage lives in the CRM. This eliminates loops and arguments over whose value is correct.
  2. External IDs and deduplication keys. The CRM record stores the ID from the other system, and lookups go by that ID, not by name or email address. That way the integration finds the existing record instead of creating a new one.
  3. Idempotent writes. Processing the same event again doesn’t change the result: the record is created or updated, but not duplicated. The HubSpot API has a batch “create or update” operation by a unique property for this (batch upsert).
  4. Retries with exponential backoff. After a 429 error or a temporary failure, the request is retried after 1, 2, 4, 8 seconds, instead of being dropped or hammering the API with retries in a loop.
  5. An event queue. Incoming events are stored first and then processed at a controlled rate. A spike of a thousand leads after an email campaign doesn’t hit the limit, but is spread over a few minutes.
  6. Logging and alerts. Every event and every step is logged, and errors that a retry didn’t fix go to the person responsible in your team chat.
  7. Regular reconciliation. Once a day a separate job compares key data in both systems - amounts, statuses, record counts - and shows the discrepancies. This is insurance against everything the other six mechanisms missed.

For your technical team, below is a simplified handler example that shows four mechanisms from the list: external ID, idempotent processing, retry with exponential backoff, and alerting.

Simplified example of a billing event handler
// Redelivery of the same event does not create a duplicate
async function handleInvoicePaid(event) {
  if (await processedEvents.has(event.id)) return; // already processed

  // look up the deal by the billing customer's external ID, not by name
  const deal = await crm.findDealByExternalId(event.customerId);
  if (!deal) {
    await alerts.send(`No deal for customer ${event.customerId}`);
    return;
  }

  await withRetry(() => crm.updateDeal(deal.id, {
    amount_paid: event.amount,
    currency: event.currency,  // the amount is always sent with a currency code
    paid_at: event.paidAt,     // ISO 8601 with time zone
  }));

  await processedEvents.add(event.id);
}

// Retry with exponential backoff on 429 and temporary errors
async function withRetry(fn, attempts = 5) {
  for (let i = 0; i < attempts; i++) {
    try {
      return await fn();
    } catch (err) {
      if (!isRetryable(err) || i === attempts - 1) throw err;
      await sleep(1000 * 2 ** i); // 1, 2, 4, 8 seconds
    }
  }
}

What to prepare before ordering an integration

A short specification saves weeks of back-and-forth and protects you from surprises in the estimate. Even if you’re not ready to describe everything, answers to these eight points let us scope the work in a single call.

  1. Systems. Which systems are being connected, on which plans, and whether there is API access and test accounts.
  2. Objects. Contacts, companies, deals, invoices, line items, calls - what exactly is transferred.
  3. Fields. A list of fields with types and sample values, including custom fields and dropdowns.
  4. Direction. For each field - where it comes from, where it goes, and which system is the master.
  5. Triggers. Which event starts the transfer: record creation, stage change, payment, schedule.
  6. Volumes. How many events on a normal day and at peak, and how many historical records need to be migrated at launch.
  7. Error handling. What to do if a record doesn’t exist, a field is empty or the other system is unavailable, and who gets the alert.
  8. Owner. Who inside the company is responsible for the integration after launch and makes decisions about changes.

For integrating a CRM with a website, the list is usually shorter: the form, the field set, UTM tags and the rule by which a submission is matched to an existing contact instead of creating a new one.

How it looked in a typical project

A typical story is a company whose integrations grew faster than their architecture. The numbers below are a characteristic range for Exceltic.dev projects of this scale, not a report on a single client.

Starting point. A B2B company of 40-60 people, sales in Kommo, invoices and subscriptions in a separate billing system, and a set of eight to twelve Make scenarios built at different times by different people. Revenue from closed deals in the CRM diverged from billing by 3-8% at month-end, the finance lead spent 4-6 hours a week on manual reconciliation, and a database audit found duplicates for 5-10% of contacts.

What we did. We replaced the scenarios with a middleware service with an event queue and wrote the billing customer ID into the contact and deal records. We made writes idempotent and added a nightly reconciliation of amounts and statuses, with a discrepancy report sent to the team chat. Historical duplicates were merged with a separate script before launch; the whole project took 4-6 weeks, including testing on a copy of the data.

Result. The revenue discrepancy between the CRM and billing dropped to a fraction of a percent and is explained by specific records in the reconciliation report, for example a refund that is still being processed. Manual reconciliation shrank to 30-40 minutes a week spent reviewing exceptions, and the team learns about failures within an hour instead of at month-end close.

Who this is for

This approach is for companies of 15 or more people whose CRM is connected to at least three systems, with money, documents or leads from paid ads flowing through those connections. Most often these are B2B services and SaaS companies on Kommo, HubSpot or Pipedrive, where management reporting is built from the CRM and a discrepancy of a few percent already affects decisions. If you have one website form and email, a native app or a simple connector scenario is most likely enough - and that’s a perfectly fine choice.

Frequently asked questions

What is the difference between a native and a custom integration?

A native integration is a ready-made app from the CRM marketplace: you turn it on in minutes, and the vendor handles support and updates. In exchange, you get a fixed set of fields and logic you can’t change.

A custom integration is built for your process via the APIs of both systems: you decide which fields to transfer, how to look up existing records, what to do on error and whom to alert. It costs more upfront and needs maintenance, but its behavior doesn’t change along with someone else’s app updates. A sensible strategy is to start with a native app and move to custom development where it stops covering your scenario.

Can you do CRM integration through Zapier or Make?

Yes, and for many tasks it’s the right choice. Zapier, Make and n8n connectors work well in one-way scenarios with a small number of fields: a form submission into a deal, a new deal into a spreadsheet, a notification to a messenger.

Problems start with two-way sync, thousands of events a day and integrations that money flows through. There the builders lack control over retries, deduplication and processing order, and the cost grows with the number of tasks or credits. If the scenario is critical, it’s more honest to calculate the total cost of ownership a year ahead, not just the launch cost.

How long does a custom CRM integration take?

The timeline depends on the number of objects, the sync direction and the quality of the other system’s API. In Exceltic.dev projects, a one-way connection between two systems for one or two objects usually takes 2-3 weeks; two-way sync involving money, reconciliation and history migration takes 4-8 weeks.

Most of the time goes not into code, but into agreeing on field mapping and sorting out historical data: duplicates, empty fields, non-standard values. A prepared specification covering the eight points from this article usually cuts the timeline by a week or two, because it removes the clarification and rework stage.

How do you know an integration has stopped working?

The most reliable sign is a discrepancy that only shows up during reconciliation: the number of deals, revenue or new leads for the week stop matching between the two systems. A failure rarely looks like an error on screen; more often the data simply stops arriving or arrives incomplete.

That’s why a reliable integration has three levels of control: a log of every event, alerts on unresolved errors, and daily reconciliation of key metrics. If you have none of these, check the latest records created by the integration and compare their count with the source for the same week.

Do you need two-way CRM data sync?

Less often than it gets ordered. In most integrations each field has a natural owner: payment lives in billing, deal stage in the CRM, call data in telephony. Then two one-way flows on different fields are enough, and loops are ruled out by the design itself.

Full two-way sync of the same field is justified when it is legitimately changed in both systems, for example customer contact details. In that case you need a priority rule, a last-modified timestamp and loop protection, otherwise the sync starts overwriting itself.

In short

  • Start with a native app: if it covers the scenario, it’s the cheapest option to maintain.
  • Connectors suit one-way scenarios with low volume and a low cost of error.
  • A custom API integration is justified where money, documents or thousands of events a day flow through.
  • Whatever the method, assign a source of truth for every field, an owner for the integration and regular reconciliation.

If you have an integration where the numbers don’t match, duplicates appear, or nobody knows whether it’s working right now, describe the task to the Exceltic.dev team: which systems are connected, which objects are transferred and at what volume. We’ll review your current architecture and tell you honestly what is enough to fix and what is cheaper to rewrite.

More articles

All
Get in touch your way
WhatsApp Telegram

Before you go: bonus months of Kommo

The implementation estimate is free: describe your sales process in a few words and we propose a solution, a plan and a quote with timelines.

We are an official Kommo partner in Europe: pay for the subscription through us and get bonus months.