Multi-currency integration: what it means in practice

This article looks at multi-currency integration in the context of connecting systems such as eBay and Shopify, where a record created in one platform has to appear correctly in the other without anyone re-keying it. The difficulty is not usually the transport; it is agreeing what each field means on each side, which direction it moves, and which system is allowed to overrule the other when both have changed. Teams that skip that conversation discover the gaps in production, one awkward edge case at a time — a second address type, a tax exemption flag, a currency that rounds differently — and each discovery pushes the timeline out.

In practice the work is a controlled layer between the two platforms. It normalises formats, holds a queue so neither side is overwhelmed during a busy hour, retries failed calls against each platform's published rate limits with exponential back-off, and records every transaction with its payload so a disputed record can be traced from end to end months later. That layer also isolates you from change: when one platform deprecates an API version, only the layer is updated, not the systems either side of it.

The test is whether you can demonstrate, three months later, why a particular value won when a disputed order becomes an argument between two departments. That means logging the inbound payload, the rule that was applied, and the value before and after, against a stable record identifier. With that log a new rule can be shadow-run against historic conflicts to see what it would have done differently; without it, every change to the logic is a leap of faith.

Multi-currency integration: naming a source of truth per field for eBay and Shopify

The failure mode is rarely dramatic. A value is changed on one side, the integration applies it late or not at all, and nobody notices until a reconciliation weeks later shows the two systems disagree. Because both systems remain internally consistent, nothing alarms anyone in the meantime. Writing the rule down before the build — one row per field, one owning system per row — is what turns a silent divergence into a decision you can point at.

Where one side has no usable API, the same outcome is reached with what exists — scheduled file exchange over SFTP, a database-level connector, or a documented REST wrapper built and hosted on the client's behalf so the legacy system can be integrated like any modern platform. The wrapper is deliberately narrow: it exposes the few operations the integration actually needs, validates every write, and never becomes a second source of truth in its own right.

None of this is exotic. It is the same short list every time: a field-level ownership table, a conflict strategy per field group, an echo-loop defence for each direction, and a specification of what the decision log records. Each takes an afternoon in discovery. Together they are the difference between an integration that is an asset and one that is a liability the first time two systems disagree.

  • Owner wins — the owning system value is always applied; the other side is rejected and logged. Correct for cost price, stock and tax codes.
  • Merge by field — each field is evaluated against its owner, so one record can accept changes from both sides in a cycle. The right default for customer records.
  • Quarantine for review — the conflicting record is parked for a human. Appropriate for anything financial.

Multi-currency integration: choosing an explicit conflict strategy

In practice the work is a controlled layer between the two platforms. It normalises formats, holds a queue so neither side is overwhelmed during a busy hour, retries failed calls against each platform's published rate limits with exponential back-off, and records every transaction with its payload so a disputed record can be traced from end to end months later. That layer also isolates you from change: when one platform deprecates an API version, only the layer is updated, not the systems either side of it.

The test is whether you can demonstrate, three months later, why a particular value won when a disputed order becomes an argument between two departments. That means logging the inbound payload, the rule that was applied, and the value before and after, against a stable record identifier. With that log a new rule can be shadow-run against historic conflicts to see what it would have done differently; without it, every change to the logic is a leap of faith.

This article looks at multi-currency integration in the context of connecting systems such as eBay and Shopify, where a record created in one platform has to appear correctly in the other without anyone re-keying it. The difficulty is not usually the transport; it is agreeing what each field means on each side, which direction it moves, and which system is allowed to overrule the other when both have changed. Teams that skip that conversation discover the gaps in production, one awkward edge case at a time — a second address type, a tax exemption flag, a currency that rounds differently — and each discovery pushes the timeline out.

Multi-currency integration: breaking the echo loop before it starts

Where one side has no usable API, the same outcome is reached with what exists — scheduled file exchange over SFTP, a database-level connector, or a documented REST wrapper built and hosted on the client's behalf so the legacy system can be integrated like any modern platform. The wrapper is deliberately narrow: it exposes the few operations the integration actually needs, validates every write, and never becomes a second source of truth in its own right.

None of this is exotic. It is the same short list every time: a field-level ownership table, a conflict strategy per field group, an echo-loop defence for each direction, and a specification of what the decision log records. Each takes an afternoon in discovery. Together they are the difference between an integration that is an asset and one that is a liability the first time two systems disagree.

The failure mode is rarely dramatic. A value is changed on one side, the integration applies it late or not at all, and nobody notices until a reconciliation weeks later shows the two systems disagree. Because both systems remain internally consistent, nothing alarms anyone in the meantime. Writing the rule down before the build — one row per field, one owning system per row — is what turns a silent divergence into a decision you can point at.

Multi-currency integration: making every decision provable after the fact

The test is whether you can demonstrate, three months later, why a particular value won when a disputed order becomes an argument between two departments. That means logging the inbound payload, the rule that was applied, and the value before and after, against a stable record identifier. With that log a new rule can be shadow-run against historic conflicts to see what it would have done differently; without it, every change to the logic is a leap of faith.

This article looks at multi-currency integration in the context of connecting systems such as eBay and Shopify, where a record created in one platform has to appear correctly in the other without anyone re-keying it. The difficulty is not usually the transport; it is agreeing what each field means on each side, which direction it moves, and which system is allowed to overrule the other when both have changed. Teams that skip that conversation discover the gaps in production, one awkward edge case at a time — a second address type, a tax exemption flag, a currency that rounds differently — and each discovery pushes the timeline out.

In practice the work is a controlled layer between the two platforms. It normalises formats, holds a queue so neither side is overwhelmed during a busy hour, retries failed calls against each platform's published rate limits with exponential back-off, and records every transaction with its payload so a disputed record can be traced from end to end months later. That layer also isolates you from change: when one platform deprecates an API version, only the layer is updated, not the systems either side of it.

Multi-currency integration: a short checklist before you build

None of this is exotic. It is the same short list every time: a field-level ownership table, a conflict strategy per field group, an echo-loop defence for each direction, and a specification of what the decision log records. Each takes an afternoon in discovery. Together they are the difference between an integration that is an asset and one that is a liability the first time two systems disagree.

The failure mode is rarely dramatic. A value is changed on one side, the integration applies it late or not at all, and nobody notices until a reconciliation weeks later shows the two systems disagree. Because both systems remain internally consistent, nothing alarms anyone in the meantime. Writing the rule down before the build — one row per field, one owning system per row — is what turns a silent divergence into a decision you can point at.

Where one side has no usable API, the same outcome is reached with what exists — scheduled file exchange over SFTP, a database-level connector, or a documented REST wrapper built and hosted on the client's behalf so the legacy system can be integrated like any modern platform. The wrapper is deliberately narrow: it exposes the few operations the integration actually needs, validates every write, and never becomes a second source of truth in its own right.

Key points

  • Name one owning system per field, not per record type.
  • Pick a conflict strategy deliberately and record it.
  • Log every decision so a change can be shadow-run later.