Skip to main content

How long does it take to build a custom integration between two business systems?

A custom integration between two business systems takes 2 to 4 weeks from kickoff to cutover when both APIs are documented, you can get API access quickly and the data is reasonably clean. Slow API access approvals, no sandbox or messy records push the same job to 6 to 8 weeks, even though the build itself barely changes.

The five phases and how long each takes

Writing code is the shortest part of most integrations. Most of the calendar goes to agreeing what the data means and proving the sync works on your real records. Here is how a typical two-system sync breaks down, in working days.

Phase What happens Working days
Discovery Map the workflow, pick a trigger and a direction for each object, list the edge cases, get API credentials 1–3
Field mapping Match fields one to one, write the rules for picklists, currencies, tax codes and missing values, decide which system wins a conflict 2–5
Build Code the sync with retries, duplicate checks, logging and alerts, then write the runbook 4–8
Testing with real data Run a copy of real records through a sandbox, reconcile totals, fix the edge cases nobody mentioned 2–5
Cutover Backfill historical records if needed, switch off the manual process, watch the first live runs 1–2

That adds up to 10–23 working days, or 2 to 4 weeks with some overlap. At Smplfy’s rate of $85 an hour, a typical two-system integration costs $1,500–$6,000. Where a job falls in that range depends on how many fields need mapping rules and how much error handling the workflow needs.

A worked example: HubSpot to QuickBooks Online to Stripe

The flow: a HubSpot deal moves to closed-won, which creates or matches a QuickBooks Online customer and a draft invoice. When Stripe confirms payment, a webhook updates the deal and marks the invoice paid.

  1. Days 1–2, discovery. We confirm that closed-won is the only trigger, that invoices stay in draft until finance approves them, and that a HubSpot private app and a QuickBooks Online app connection can be authorized.
  2. Days 3–6, mapping. HubSpot line items map to QuickBooks products. We agree which identifier matches a customer (QuickBooks has no HubSpot ID field, so we store one in a custom field or our own lookup table), and set a rule for deals that have no line items.
  3. Days 7–13, build. The sync uses idempotency keys so a retried webhook cannot create a second invoice. It backs off and retries on rate-limit responses, and it queues any Stripe payment that arrives before its invoice exists.
  4. Days 14–17, testing. We run a month of real closed deals through the QuickBooks sandbox company and reconcile invoice totals against the deals to the cent.
  5. Days 18–19, cutover. We turn the sync on, watch the first live deals and hand over the runbook.

This is about 19 working days, or four calendar weeks, and it only holds if every credential arrives in the first two days. One late admin approval moves every phase after it.

What slows an integration down

Almost every delay comes from one of the items below, and most of them have nothing to do with engineering. These are the delays we plan for in a schedule.

Factor Typical added time How to avoid it
API access approvals 3–10 days Find out on day one who holds admin rights in each system; some apps need IT or vendor review
No sandbox or test environment 3–7 days Check whether your plan includes a sandbox, or agree a safe test record convention in production
Dirty data: duplicates, inconsistent names, blank required fields 1–3 weeks Run a duplicate and completeness check before mapping; clean the worst 10% first
Custom fields with unclear meaning 2–5 days Name one person who can say what each field means and which system owns it
Large historical backfill 2–5 days Backfill only what reporting needs; rate limits make bulk loads slow
Scope added mid-build 1–2 weeks per object Ship the first object, then add the next as a second phase

The ones people don’t see coming

  • Re-authentication. OAuth tokens expire or get revoked when the admin who authorized them leaves. If you plan for a service account during discovery, this won’t break the sync three months later.
  • Data that arrives out of order. A payment webhook can arrive before the invoice it belongs to. Without a queue, it either fails or creates an orphan record.
  • Upstream field changes. Someone renames a picklist value in HubSpot or Salesforce and the mapping quietly stops matching. Alerts on unmapped values catch this on day one, not at month-end.
  • Partial failures. One bad record in a batch of 200 should not stop the other 199. Building the sync to handle each record on its own takes extra time, but you only pay for it once.

What a finished integration should include

The timelines above cover more than code that moves data. They include logging so every sync can be traced, an alert when a record fails, a way to replay failed records, and a runbook that says what to do when a token expires or an API changes.

Leave those out and you get a faster build that fails quietly. With them, an integration can run for years. A Stripe-to-Salesforce and Google Sheets finance sync we built has run for two years with minimal maintenance.

When to build, when to use no-code, when to wait

  • Use Zapier, Make or n8n if the flow is one-directional, creates records rather than updating them, and runs fewer than a few hundred times a month. You can set it up in an afternoon, and an hour of checking a week is usually enough to catch failures.
  • Build custom if the sync is two-way, money is involved, duplicates are expensive, or the volume will hit the rate limits that no-code tools handle poorly. Two to four weeks is the realistic price of something you can trust.
  • Wait if you can’t name who owns each field, or the process still changes every month. Write the process down first. An integration built on an unsettled process gets rebuilt.

Frequently asked questions

How long does a simple two-system integration take?
A two-system sync with documented APIs and clean data usually takes 2 to 4 weeks, from discovery through cutover. The build itself is often 4 to 8 working days. The rest is field mapping, testing with real data and switching over safely.

Why do integrations take longer than the developer estimated?
The most common reasons are waiting for API access approvals, having no sandbox to test in, and dirty data such as duplicate customers or blank required fields. Each can add one to three weeks. None of them is about writing code, so check all three before the project starts.

Can an integration be built in a few days?
A one-way, create-only flow in Zapier or Make can be set up in a day. A custom integration with duplicate handling, retries, logging and testing on real data takes longer. Anyone quoting a few days for a two-way sync is probably skipping testing or error handling.

What should I prepare before an integration project starts?
Have admin access, or the person who has it, for both systems, and check whether either system has a sandbox. Bring a list of the fields that matter, plus a sample export of real records. Name one person who can decide what each field means and which system wins a conflict.

How much does a custom integration cost compared with how long it takes?
At Smplfy, a typical two-system integration costs $1,500–$6,000 at $85 an hour. That is roughly 18 to 70 hours of engineering spread over 2 to 4 weeks. The price rises with the number of fields that need mapping rules and the amount of error handling the workflow needs.

Related answers

Want a realistic timeline for your two systems?

We’ll send a short written scope with a week-by-week plan, or talk it through on a free 20-minute call. Have ready the two systems, roughly how many records move each month, and what your team does by hand today. Start a conversation.