Skip to main content

APIs and Systems Integration

Documented APIs and an integration layer that keeps your systems in step — and alerts you when it cannot.

The problem we solve

On a slide, integration is two boxes and an arrow. In production, systems disagree about field names, units and update timing; one goes down and a message is lost or delivered twice. What we usually inherit is a set of scripts written under deadline pressure, with no documentation, no logging and no retry logic, understood by exactly one person who may no longer be there. Every vendor update becomes a risk, and a data error discovered late becomes an accounting or operations problem. We build integrations to survive those conditions rather than to demo well.

Expected outcomes

  • Manual re-entry between systems removed, along with the copying errors it produces.
  • An agreed source of truth for each type of record instead of competing versions.
  • Faster reporting because data arrives consistent and current.
  • The ability to replace one system later without rebuilding everything around it.
  • Immediate alerts when a sync fails, rather than a discovery at month-end.
  • Documented APIs that let partners or your own apps connect on clear terms.

Who this is for

  • Companies running an ERP, an accounting package and an online store that do not speak to each other.
  • Operations teams whose process depends on exporting spreadsheets and uploading them again.
  • Technology firms that need a partner-facing or internal API.
  • Organisations mid-way through replacing a legacy platform and needing a bridge.
  • Product teams whose mobile app needs safe access to internal data.

Use cases

  • Keeping orders and stock in step between an online store and the warehouse system.
  • Pushing invoices and journal entries from operations into the accounting platform.
  • Feeding website forms and lead sources straight into the CRM.
  • Unifying customer records across support and sales so one view exists.
  • Building an API consumed by a mobile app or an external partner.
  • Connecting payment gateways, shipping carriers and messaging providers to your core system.

Deliverables

  • A working integration layer or API running in production.
  • An architecture document showing data flow, direction and ownership.
  • Technical API documentation in OpenAPI format with worked examples.
  • A field mapping approved by your operations team.
  • Monitoring and alerting configured for failure conditions.
  • A short runbook: what to do when a job fails and how to replay it.
  • A sandbox environment separated from production.

Project phases

Audit

Mapping the systems, their real interfaces and constraints, and identifying the highest-impact flows.

Integration design

Sync direction, source of truth, field mapping and how each failure scenario is handled.

Build

Developing the interfaces, transformation logic, security and error handling in reviewable increments.

Testing

Realistic data in an isolated environment, including outages, duplicates and incomplete records.

Parallel run

Running the integration next to the current manual process and reconciling results before cutover.

Handover & stabilisation

Monitoring and alerts live, team walkthrough of the runbook, and support through the warranty window.

Estimated timeline
4 to 12 weeks
An estimate that depends on scope and how quickly reviews come back — not a contractual commitment in itself.
Pricing
After scoping
Scope is driven by how many systems are involved, how good their interfaces are, data volume and the complexity of the transformation rules. We give an initial assessment after the audit session, then a scoped proposal.

Scope and working details

What is in and out of scope, how we work, and what we need from you.

What is included

  • An audit of current systems and what their interfaces genuinely support.
  • Agreement on sync direction, source of truth and update cadence for each data entity.
  • Field mapping between systems, including format and unit mismatches.
  • Design and build of the integration layer or API, depending on the case.
  • Security: authentication, scoped permissions, rate limiting and encrypted transport.
  • Failure handling: exponential retries, deduplication keys and a dead-letter queue.
  • An operations log and view so your team can see what ran, when, and where it stopped.
  • API documentation and a sandbox environment developers can test against.
  • Testing on realistic data and a parallel run before full cutover.

What is not included

  • Licences, subscriptions and API usage fees for third-party platforms.
  • Obtaining approvals or vendor certifications on your behalf.
  • Rebuilding or extending the internal systems themselves beyond the integration points.
  • Connecting to platforms with no interface and no vendor cooperation, without a separate feasibility study.
  • Ongoing operation and monitoring after the stabilisation window, unless covered by a support agreement.

How we work

We begin with an honest audit of what your systems actually expose, not what the brochure claims — most integration delays trace back to a third-party limitation discovered too late. Next we settle, in writing, which system owns each record; that is a commercial decision as much as a technical one. Delivery is incremental, starting with the flow that saves your team the most time, and we run it alongside the existing manual process until the numbers match and you are comfortable switching off. Everything ships with documentation another developer can pick up.

What we need from you

  • Technical access to the systems involved, or coordination with their vendors.
  • An operations owner who can settle business rules and ownership conflicts.
  • Existing documentation, or someone on your team who can explain the systems.
  • A realistic data sample for testing, handled with appropriate privacy care.
  • A test environment, or permission to create one on the platforms involved.

Methodology and technology

REST APIs by default, with GraphQL where varied client consumption justifies it. Documentation as an OpenAPI specification with a sandbox. Authentication via OAuth or signed keys depending on the consumer, with rate limiting and narrowly scoped permissions. Asynchronous work handled through message queues and webhooks, with idempotency keys, exponential backoff and a dead-letter queue. Centralised logging, monitoring and failure alerts. Explicit API versioning so consumers are not broken by an update.

From our work

How this connects to the rest of our work

A service rarely works alone. These come before it or alongside it, and these are the solutions it forms part of.

Services that work with it

Part of these solutions

Frequently asked questions

Our systems are old and have no API. Can they still be integrated?

Usually yes, but through different routes: read access to the database, scheduled file exchange, or a service layer we build over the platform. We assess the options and explain the trade-offs and limits of each before committing. We will not promise a connection the system cannot support.

What happens if a system goes down mid-sync?

The design assumes outages. Work is queued and retried with increasing intervals, and idempotency keys prevent the same operation being applied twice. Anything that fails permanently lands in a dead-letter queue with an alert, so your team sees it instead of it passing silently.

Who owns the API and the code?

You do. Code, documentation and credentials are handed over in your company name, in a repository you control. We build on open components and avoid creating dependence on anything proprietary to us.

How is sensitive customer data handled during integration?

We move the minimum data each flow needs, encrypt it in transit, and apply field-level permissions where warranted. Test environments use masked data wherever practical. Any regulatory obligation specific to your sector is reviewed with your own legal advisers before implementation.

What if a third-party provider changes their API later?

Each provider is isolated behind its own adapter, so a change is contained at one point rather than spreading through the system, and monitoring flags behaviour changes early. The update itself is handled as maintenance under a support agreement or as a defined change request.

Can you work alongside our in-house technology team?

Yes, and it is a common arrangement. We agree a clear split of responsibilities, work in your repository to your standards, and finish with documentation and a knowledge-transfer session so your team can operate and extend the work.

Have an idea, or a system that needs work?

Start with a short session to understand where you stand and what the next step should be. If the scope is clear, a written proposal follows.