Skip to content

REST | GraphQL | ERP

ERP, CRM, payment, logistics and PIM connected to your commerce platform, with the failure behaviour defined rather than discovered. The least glamorous work on this site and the most frequently load-bearing.

How engagements work

In one paragraph

Not the happy path, which is a day of work. What takes the time and determines whether the integration survives is the rest: what happens when the other system is down, what happens when the same message arrives twice, what happens when a field is null that has never been null before, and how anyone finds out that any of it happened. An integration without retries, idempotency and observable failure is not finished, it is merely working for now.

What this is

Integration is where commerce projects quietly go wrong. The demo works, the launch works, and three months later someone notices that stock has been drifting since a timeout nobody saw.

The work is unglamorous and specific: define what each system owns, define what happens on every failure, make failure visible, and make the whole thing replayable. Most of the cost is in the second and third, and most integrations skip both.

What this page is not

This covers integration as its own engagement. Where the integration is one part of a larger platform build, it is usually better scoped inside that project.

What usually brings this in

  • Stock in the store and stock in the ERP disagree.

    Oversells, cancellations, and a support team manually reconciling two systems daily.

  • An integration fails silently.

    Nobody finds out for days, the recovery is manual, and nobody can say how many records were affected.

  • Orders occasionally duplicate.

    A retry somewhere is not idempotent, and finance is reconciling by hand.

  • The integration was built by someone who has left.

    It is undocumented, nobody will change it, and it is in the path of every order.

What gets built

Ownership defined before anything is written
Which system is authoritative for product, price, stock, customer and order. Most integration bugs are really two systems both believing they own a field.
Idempotent, retryable message handling
Every operation safe to repeat, every message traceable, with queues where the volume or the failure cost justifies them.
Observable failure
Failures that alert rather than accumulate, with enough context to act on and a replay path that does not involve a database console.
REST and GraphQL API design
Versioned, documented and authenticated properly, built for the consumers that exist rather than for every consumer that might.
ERP, CRM, payment and logistics connectors
The systems commerce platforms actually have to talk to, including the ones with documentation written in 2011.
Rescuing an integration nobody owns
Read it, document it, make it observable, then change it. In that order, because changing an undocumented integration in the order path is how a bad week starts.

Technologies

Protocols
  • REST
  • GraphQL
  • Webhooks
  • SOAP
  • SFTP
Messaging
  • RabbitMQ
  • Queues
  • Retries
  • Dead letter handling
Systems
  • ERP
  • CRM
  • PIM
  • 3PL
  • Payment gateways
Platform
  • Magento 2
  • Shopify
  • Node.js
  • PHP
  • AWS

How delivery runs

  1. Map what exists

    Every system, every flow, and which of them anyone is currently watching. This map almost never exists and is frequently the most useful part of the engagement.

  2. Agree ownership

    One authoritative system per field, written down. Disagreements surface here, on paper, rather than in production at volume.

  3. Design the failure behaviour

    What happens on timeout, on duplicate, on malformed data, on the other side being down for an hour. Before the happy path is built, not after.

  4. Build, with the logging first

    Observability goes in as the integration is written. Added afterwards it is always thinner than it should be.

  5. Run it in parallel

    Alongside the existing process where one exists, comparing outputs, until the comparison is boring. Then switch.

Questions

Can you integrate with our ERP? It is quite old.
Usually, and age is rarely the obstacle. What matters is whether it exposes anything at all: an API, a database view, a scheduled file drop. All three are workable and they have very different failure characteristics, which is the thing to establish first.
Our integration works. Why would we change it?
If it has retries, idempotency and alerting, you would not, and that is a real answer. If none of those is true it is working by luck, and the usual trigger for finding out is a volume increase or a dependency outage.
Should this be real-time or batched?
Per flow, against what the business tolerates. Stock usually wants to be near-real-time; a nightly product export is fine batched and considerably cheaper to run. Making everything real-time is a common and expensive default.
Can you document an integration we already have?
Yes, and for anything in the order path it is worth doing before it needs changing. The output is the map, the failure modes and the replay procedure.

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