Skip to content
ERP | CRM | Middleware

Stock, pricing, orders and customers synchronised between the storefront and the systems that run the business, with the failure behaviour designed rather than discovered.

How engagements work

In one paragraph

What makes an eCommerce ERP integration reliable?

Deciding three things before any code: which system owns each field, what happens when the other one is unavailable, and how a disagreement is detected. Ownership stops two systems writing the same value and overwriting each other. A queue with retries and backoff turns an ERP outage into a delay rather than a lost order. Scheduled reconciliation catches the drift that inevitably accumulates anyway, and reports it instead of waiting for a customer to find it. Most failing integrations fail on those three questions rather than on the API, which is why rewriting the connector rarely fixes them.

What this is

An integration is rarely a technical problem first. It is a question about who owns what: if the ERP owns stock and the store owns price, both systems can be right at once. If neither owns anything clearly, both are authoritative, and the last write wins in a race nobody is watching.

The second thing that decides whether an integration holds is what it does when the other side is down. A direct call that fails loses an order. A queued message with retries and a dead-letter path turns the same outage into a delay and a visible alert. The difference is an afternoon of design and it is the difference between an integration people trust and one they check manually.

On the record: 90% of B2B order and quote processing automated on a Magento platform, with the systems behind the store wired in rather than reconciled by hand afterwards.

What this page is not

This page is about connecting business systems. If the work is building or exposing an API rather than integrating two systems that already have them, that is the API page.

What usually brings this in

  • The store and the ERP disagree about stock.

    Oversells, cancellations and a support team doing data entry to keep two systems in step.

  • Sync is a nightly CSV export.

    Everything that happens between exports is invisible, and the gap is exactly where the expensive mistakes live.

  • When the ERP goes down, orders are lost.

    A back-office outage becomes a revenue outage, because the integration was built as a direct call.

  • Nobody can say which system is right.

    Reconciliation is a weekly meeting, and decisions get made on whichever report is open.

What gets built

A field ownership map, first
Which system is authoritative for stock, price, customer, order status and product data, written down and agreed before a line of code. This single document prevents most of what goes wrong later.
Queued, retried, observable sync
Message queues with backoff and a dead-letter path, so an unavailable system causes a delay and an alert rather than a lost transaction. RabbitMQ on Magento, webhooks and workers elsewhere.
Order and fulfilment flow
Order down to the ERP or WMS, status and tracking back up, with idempotency so a retried message cannot create a second order.
Customer and CRM sync
Accounts, segments and order history into the CRM with consent and data-protection boundaries respected, so marketing works from the same customer the finance system has.
Product and pricing feeds
Catalogue, attributes, account-specific pricing and tax rules from the ERP or PIM, with validation at the boundary rather than a bad record propagating silently.
Reconciliation and alerting
A scheduled job that compares both systems and reports the difference. Drift happens on every integration; the only choice is whether you find out from a report or from a customer.

Technologies

Transport
  • REST APIs
  • GraphQL
  • Webhooks
  • SFTP
  • RabbitMQ
Commerce
  • Magento 2
  • Adobe Commerce
  • Shopify
  • WooCommerce
Business systems
  • ERP
  • CRM
  • WMS
  • PIM
  • Accounting
Reliability
  • Queues
  • Idempotency
  • Retry and backoff
  • Reconciliation jobs
  • Monitoring

How delivery runs

  1. Map the systems and the fields

    What exists on both sides, what each one is authoritative for, and where the two currently disagree. The disagreements found here are usually already costing money.

  2. Agree ownership in writing

    One owner per field, signed off by the people who run both systems. This is a business decision wearing a technical hat, and it cannot be made by the integration.

  3. Design the failure behaviour

    What happens when the other side is slow, down or wrong. Queue, retry, dead-letter and alert, decided now rather than discovered during a sale.

  4. Build with the logging first

    Every message in and out, correlated, before the business logic. An integration you cannot observe is one you will be debugging by guesswork at the worst possible time.

  5. Run in parallel, then cut over

    The new path running alongside the old one with the differences reported, so cutover is a decision made on evidence rather than a date in a plan.

Questions

Do you work with our specific ERP?
The question that matters is what it exposes: a REST or SOAP API, a database, a file drop, or a middleware layer. Those four cover nearly every system, and the integration pattern is chosen from them rather than from the vendor name. Where the ERP is genuinely closed, the honest answer is a file-based integration with reconciliation, and I will say so rather than quote for an API that does not exist.
Real-time or scheduled sync?
Per field, not per integration. Stock usually needs to be near real time because the cost of being wrong is an oversell. Product descriptions can run nightly because nobody is harmed by a six-hour delay. Deciding this per field rather than globally is what keeps the load reasonable.
Should we use middleware or point to point?
Point to point is fine for two systems and becomes a liability at four, because each new system multiplies the connections. If a third and fourth system are already on the roadmap, a middleware layer pays for itself; if they are not, it is architecture bought ahead of need.
How long does an integration take?
The build is rarely the long part. Establishing what each system actually contains, and getting agreement on who owns which field, routinely takes longer than writing the connector, and skipping it is why integrations get rebuilt.

Describe what is in front of you and you get a written scope and a figure, usually within a few days of a short call. No charge for either.

All services