SERVICES

Integrations
done right

Most growing businesses end up with tools that should work together and don't. We build the integrations and automations that fix that.

The catalogue below covers the kinds of jobs we take on. Most start with discovery so we know what we're building before we quote a price.

Integration Audit

We audit your stack and hand back a prioritised list of fixes, ranked by what each one is costing the business.

— What you get

  • Full inventory of tools, data flows, and the manual workarounds quietly holding things together
  • Structural risks scored by cost to the business, not by how interesting they are technically
  • Costed roadmap for the next one to three integrations or automations worth building
  • Walkthrough call with your engineering team to talk through the findings

— Not this

Corporate strategy consulting. This is a technical diagnosis, not a deck

Custom Integration Build

Connect the systems that should already be talking. Sync them in real time, and keep them stable when one of them changes.

See it shipped Mirakl → Mintsoft for a 3PL →

— What you get

  • Schema and data-flow design across the systems involved
  • Middleware shipped to production, on your infrastructure or ours
  • Retry logic and monitoring so failures get caught and recovered rather than discovered weeks later
  • Runbooks your on-call engineer can actually use when something does go wrong

— Not this

Rebuilding features your existing tools already do natively

Workflow Automation

The repetitive work someone in ops is doing manually every week, turned into software that runs on its own.

See it shipped Royal Mail claim automation →

— What you get

  • Process map of the workflow as it actually runs today, edge cases included
  • Custom automation that plugs into the tools your team is already using
  • AI where judgement is required: parsing free-text, classifying inputs, or extracting data from documents
  • Dashboards and alerts so the team knows what ran and what failed
  • Handover session with the people who own the process internally

— Not this

Decisions that genuinely need a human reading the situation

Managed Integrations

Ongoing engineering to keep what we built running, and to ship the next thing when you need it.

— What you get

  • Monitoring and alerting on every integration we own
  • Incident response inside an agreed SLA
  • API and schema changes handled before they break the integration
  • Quarterly review of what's running and what should be retired or replaced

— Not this

A break-fix helpdesk with no context on your business

ENGAGEMENT

How an engagement runs?

Most engagements move through three stages: discovery that maps your stack, a build that delivers what discovery scoped, and optional support that keeps it alive.

Most agencies hide what they charge. We post the ranges below. Prices get fixed when we scope the work, and only change if the scope does.

01

Discovery

1–3 weeks · $500–$2,000

We dig into your infrastructure to map data flows and find where it's breaking. You get a written diagnosis, not a sales pitch.

  • Full stack inventory and architectural data-flow map
  • Prioritised list of structural risks ranked by cost to the business
  • Scoped, costed roadmap for the fixes we recommend
  • Walkthrough call with the team
02

Build

2–12 weeks · typical $5k–$25k

We build what the discovery roadmap costed. Everything is scoped before engineering starts, and the price is fixed on sign-off.

  • Technical specifications signed off before we write code
  • Custom middleware, automations, and integrations shipped to production
  • 30-day post-launch fix window
  • Written runbooks and monitoring so the team that owns it knows what to do
03

Support

optional

Monthly · from $500/month

Ongoing engineering to keep what we built running. We maintain it and ship small features as you scale, and we catch breaking changes before they hit you.

  • Monitoring and alerting on every integration we own
  • Bug fixes and small feature work within an agreed SLA
  • API changes handled before they break the integration
  • Monthly review of what shipped and what's next

TRACK RECORD

Solutions
that scale

Case study · 01
“Kept a major client by building the integration that didn't exist.”

Mirakl Mintsoft for a 3PL

Many-to-many order splitting, inventory sync, marketplace fulfilment.

Read the full study
Case study · 02
“240+ hours/year saved, hundreds of $ recovered monthly.”

Royal Mail claim automation

AI-powered Xero + Linnworks workflow filing claims in seconds, not minutes.

Read the full study
Case study · 03
“Eliminated manual stock checks between two systems.”

Tradegecko legacy WMS

Secure sync into a warehouse system with hard limits and no public API.

Read the full study

FAQ

Got questions?
start here

What is the typical timeline for an integration project?
Discovery takes one to two weeks. A typical integration ships in two to eight weeks after that, depending on how many systems are involved and how well-behaved their APIs are. We scope the work in detail before quoting, and the price doesn't move once we start. Those dates assume timely access to sandbox credentials and quick answers on business rules. If we're blocked waiting on either, the timeline shifts with it.
How much of my team's time will this take?
We do all the coding, but we can't build this in a vacuum. Expect around 2-5 hours in the first week getting us access and walking us through your workflow, plus an hour or two at the end to sanity-check what we've shipped. We move fast, but if business questions sit unanswered for days, the project stalls.
Will this disrupt our live operations?
It shouldn't. We build and test everything in a sandbox while your business keeps running as normal. Live data is always less predictable than test data, so we cut over during your quietest hours and stay online to monitor the first live syncs, catching anything odd before customers notice.
What happens when something breaks?
Third-party APIs go down, humans type strange things into forms, and AI components occasionally misclassify an input or hallucinate a value. Some of that is predictable, some of it isn't, and AI in particular is non-deterministic by design, so we add guardrails and human review wherever the stakes are high. Monitoring and error resilience is a core principle for us: every integration we ship is instrumented to surface failures the moment they happen, so nothing sits broken in silence. We respond quickly and do our best to get things back on track, whether that's a one-line fix from us or a quick retry once a value is corrected.
How do you handle third-party API changes post-launch?
Clients on a retainer get API changes handled before they break the integration. Clients without one get a 30-day fix window after launch. After that, ad-hoc work is billed at our standard rate, or you can move to a retainer.
Do you sign NDAs, and how are our credentials secured?
Yes, we sign NDAs as standard. Credentials live in a secrets manager (1Password, Doppler, or whatever you already use), scoped to the minimum permissions the integration needs. They never go in source code or into the repo.
Who retains ownership of the developed code?
You own the code. We commit directly to your repo, or hand it over at the end of the engagement. No platform lock-in, no licence fees, no black-box middleware sitting between you and the systems it touches.
Do you provide ongoing maintenance after the project launches?
Maintenance is optional. Every project includes a 30-day fix window after launch. After that you can move to a retainer from $500/month, or take it in-house. Either way, you get the runbooks.
Are you able to integrate with legacy systems that lack a public API?
Yes. When there's no modern API, we work with what's available: SFTP/CSV, direct database access, SOAP, or scraping as a last resort. Our Tradegecko case study is exactly that. A warehouse system with no public API and hard operational constraints, integrated end-to-end.
Can you work with proprietary or lesser-known software?
Yes. Most of our work is fully custom, and niche or in-house tools are normal for us. If your system can expose data somehow (API, flat file, database, or webhook), we can integrate it.
We want to use AI but don't know where it fits. How do we figure that out?
Most clients want AI but aren't sure where it fits. The audit is the first step because AI works best on workflows that are already cleanly defined. We map how the process actually runs, tidy up the chaos, then layer AI only where judgement is genuinely needed: reading free-text emails, classifying messy inputs, or extracting data from documents. Skip the cleanup and you'll just have AI making the same mess faster.
What is your scoping and pricing model?
We start with discovery to scope the work and price it. Delivery is fixed-price once signed off, and only changes if the scope does. Ongoing support runs on a monthly retainer.

Ready
to scope?

Didn't see your question above? Book a call to talk it through, or email your stack and we'll come back with a one-page read on where to start

Book a free call Email your stack