API & third-party integrations
so nobody re-types data.
CRMs, ERPs, payments and internal tools connected so the data stops being re-typed by people.
- — Someone exports a CSV weekly to keep two systems aligned
- — Sales and finance disagree about the same customer record
- — An integration breaks silently and you find out from a client
The work should
change the numbers.
Integration work is where most digital projects quietly lose their time. Two systems each hold a version of the truth, the field names nearly match, and a capable person spends four hours a week reconciling the difference by hand.
We treat integrations as products rather than plumbing. That means an explicit contract, defined behaviour when the far end is down, idempotent writes, replay tooling and monitoring that tells you a sync is failing before a customer does.
Sometimes the right answer is a managed connector and thirty minutes of configuration. We will tell you when that is the case rather than billing you for a bespoke pipeline you did not need.
What the engagement
actually contains.
Systems and data mapping
The source of truth for each field agreed, and conflict rules decided before anything is written.
Contract-first development
Typed schemas and generated clients so a change upstream fails at build rather than in production.
Resilience patterns
Retries with backoff, idempotency keys, circuit breakers and dead-letter queues as standard.
Webhook infrastructure
Signature verification, replay endpoints and event logs for every inbound and outbound event.
Sync monitoring
Dashboards and alerts on lag, failure rate and record counts, owned by a named person.
API publishing
Where you are the provider: versioning, authentication, rate limiting and developer documentation.
- Integration services deployed and monitored
- Field mapping and conflict-resolution specification
- OpenAPI schema and generated clients
- Event log with replay tooling
- Alerting rules and on-call runbook
- Developer documentation for published APIs
- Someone exports a CSV weekly to keep two systems aligned
- Sales and finance disagree about the same customer record
- An integration breaks silently and you find out from a client
- Your partners are asking for API access you cannot provide
What usually went wrong
before we were called.
- 01No agreed source of truth per field, so both systems overwrite each other
- 02Retrying without idempotency keys and creating duplicate records
- 03Silent failures with no alerting and no replay path
- 04Building a bespoke pipeline where a supported connector would do
- Sync success rate and lag
- Manual data entry hours removed
- Duplicate and mismatch rate
- Time to detect a broken integration
2–6 weeks per integration, depending on the far end
What week one
actually looks like.
Field-level mapping with an agreed source of truth per field and a written decision on behaviour when the far end is unavailable. Then a sandbox sync before anything writes to production.
- API credentials for both systems
- A data owner to settle conflicts
- Volume and frequency expectations
- Sandbox environments where available
- Third-party licence or API usage fees
- Cleaning historical data quality issues
- Changing the far system’s own logic
- Ongoing manual reconciliation
Scope boundaries stated up front rather than discovered in a change request.
Four stages, visible throughout.
Model
The domain, data and permissions written down before any interface exists, because the schema outlives every screen above it.
Prototype
Flows and states tested as a clickable prototype, so the expensive disagreements happen in Figma rather than in code.
Ship in slices
One workflow at a time, in production, with tests and observability included in the definition of done.
Operate
Release tooling, monitoring and a documented handover so your team can run and extend what we built.
API & third-party integrations, answered.
Buy when the mapping is standard, the volume is modest and the vendor supports both ends. Build when the logic is yours, the volume is high, or the connector cannot express your rules without a fragile pile of filters. We audit that honestly — a build we do not need is bad business for both of us.
Defined behaviour, agreed with you in advance: queue and retry, degrade gracefully, or fail loudly. The point is that the answer is a decision rather than an accident, and that the queue drains automatically when service returns.
Yes. Typical findings are missing idempotency, unverified webhooks, no retry policy and no alerting. We stabilise first, monitor second, then improve — usually in that order, because stability is what stops the support tickets.
SaaS & custom software
Product engineering for the system your business runs on and no vendor sells off the shelf.
Database design & development
Schemas, queries and migrations that stay fast and honest as the data grows.
Custom admin dashboards
Internal tools your team actually wants to open, built around the decisions they make daily.
Payment gateway integration
Stripe, PayPal, Adyen and regional gateways wired in with tax, refunds and edge cases handled.
Make api & third-party integrations useful.
Bring us the hard thing. We will bring a point of view, a senior team and a clear next step.