Free Tool
Integration complexity score
Connecting two systems sometimes takes three days and sometimes three weeks. Six factors decide which — this tool scores them.
The score comes from six inputs: how many systems are involved, which way the data flows, how often it transfers, how the other system exposes its data, how many fields must be mapped, and whether error handling is required. Every factor’s points are written out below. The result lands in one of three risk levels and maps to KodDelta’s published budget bands. There is no unmeasured success rate or average duration claimed anywhere on screen.
The score is an estimate, not a quote. Scope is fixed once the other system’s documentation is reviewed. Tell us about your systems →
How the points are assigned
| Factor | Points | Reason |
|---|---|---|
| Each additional system | +2 (on n−1) | Every new system adds a contract, an identity and a failure source |
| Two-way flow | +3 | Requires conflict resolution, an authoritative-source decision and loop protection |
| Hourly transfer | +2 | Scheduling, locking and partial-failure handling come into play |
| Real-time transfer (event / webhook) | +4 | Ordering guarantees, duplicate-message protection and queue infrastructure |
| Legacy API (SOAP / proprietary) | +2 | Thin documentation, opaque error messages, usually no test environment |
| File transfer (CSV / FTP) | +3 | Partial files, encoding differences and reprocessing problems |
| Direct database read | +4 | Undocumented schema; breaks on every release from the other side |
| No API (screen / report output) | +6 | The structure breaks with every interface change; needs continuous maintenance |
| Field count | +1 per 10 fields (max +5) | Every field is a mapping decision and a validation rule |
| Over 50,000 records per day | +2 | Batching, pagination and timeout handling required |
| Reconciliation + retry | +2 | A separate report, a separate queue and an alerting mechanism |
| Code / unit conversion | +2 | The two systems do not share a vocabulary; lookup tables need maintenance |
| Enterprise authentication | +2 | SSO, certificate or VPN setup needs coordination with a third party |
| Total score | Risk level | Published band | Rough duration |
|---|---|---|---|
| 0 - 6 | Low | Standalone integration item inside $3,000 - $6,000 | 1-2 weeks |
| 7 - 13 | Medium | $3,000 - $6,000 (within single-process scope) | 2-4 weeks |
| 14 and above | High | $8,000 - $15,000 (enterprise scope) | 4-8 weeks |
The points reflect KodDelta’s own integration experience; we do not claim they are a measured industry standard. The bands on screen are the same bands published on the pricing page.
Four ways to bring the score down
The real value of this tool is not the number — it is seeing which decision reduces it. Try these four adjustments:
- Turn two-way into one-way. Most integrations described as “it has to be two-way” turn out to be one-way in practice: records are created on one side and only statuses update on the other. Write down which field is authoritative in which system and one direction is usually enough.
- Step real-time down to hourly. “It should be instant” is usually a habit rather than a requirement. If the answer to “what happens if the order lands five minutes later” is “nothing”, an hourly design is both cheaper and more robust.
- Cut the field count. You do not have to move every field in the first release. Start with the core fields the work depends on; adding the rest later is cheaper than adding them up front.
- Upgrade the access method. Ask the other vendor about their official API. Most packaged ERPs have one, sold as a separate module — and that module usually costs less than the maintenance burden of scraping screens.
Reconciliation: the most skipped part of an integration
An integration works on the day it is built. The real question is whether it still works six months later and who would notice if it did not. Silent failure is the most expensive integration bug there is: data stops flowing, nobody notices, the two systems live apart for weeks, and the gap surfaces at month end.
That is why every integration needs three things: a record of every run, a regular reconciliation report comparing totals on both sides, and an alert that reaches a human on failure. Those three raise the build cost slightly and lower the maintenance cost significantly.
Integration, or one system?
Sometimes the right answer is not integration at all. If you find yourself constantly shuttling data between two systems, ask whether there is a genuine reason for the data to live in both. Accounting and e-invoicing should stay separate; but a split like “stock in one program, orders in another” is usually a historical accident, and keeping it alive with an integration costs more in the long run than consolidating into one system.
To make that call with figures, use the 5-year TCO comparison and add the integration maintenance into the workaround labour line — the table changes. To see the band for the whole scope, use the budget and timeline estimator; to see which systems we work with, visit the integrations page.
Frequently Asked Questions
What makes an integration hard?
Not the number of systems, but three other things: which way the data flows, how often it flows, and how the other system exposes it. A one-way transfer running once a day over a modern API can be built in a few days. A two-way, real-time link needs conflict resolution, ordering guarantees and retry logic — and those three are the bulk of the work.
Why is two-way integration so expensive?
Because it means the same record can change in two places. Someone has to decide which side wins, which field is authoritative in which system, and what happens on conflict. Those are business decisions, not technical ones, and they are usually the longest discussion in the project. Where a one-way design is possible it is always preferred.
What if the other system has no API?
It can still be done, but it gets more expensive and more fragile. The order of attack is: official API, the vendor’s file-based export, direct read-only database access under licence, and as a last resort processing scheduled report output. The last two need maintenance every time the other side releases a new version, and the score reflects that with a multiplier.
Does the score give me a price?
The score maps you to a published band, not to a single figure. A small standalone integration item sits inside the $3,000 - $6,000 band. Where the integration is part of a wider system project, the scope lands in $3,000 - $6,000 or $8,000 - $15,000 depending on breadth. The exact figure is set once the other system’s documentation has been reviewed.
Why is a reconciliation report a separate line item?
Because an integration that fails silently is more dangerous than one that was never built. A report that regularly compares totals across both systems surfaces the discrepancy on the day it appears. Combined with retry logic, that is the difference between an integration that survives five years and one that is quietly forgotten after three months.
Let us review the other system’s documentation
In 30 minutes we can tell you which path is open and give you a realistic duration.