One source of truth
Data that moves between systems once, correctly, with no double entry.
Service 12 of 15
API & integrations
APIs and integrations that connect your systems, partners and data.
- Typical timeline
- 3–10 weeks
- Pricing
- Fixed quote
- Team
- 2 backend engineers
Our 3 promises
Your systems. Our goal.
Three promises we make on every integration project.
Secure connections
Authentication, encryption and audit logs on every endpoint.
Easy to extend
Clean, documented APIs that new tools and partners can plug into.
Tech stack
The stack behind your api & integrations
Proven, well-supported tools at every layer. Picked for your product, never for our habits.
- APIsgRPC
- APIsMost requestedREST
- APIsOpenAPI
- BackendPython
- APIsMost requestedGraphQL
- Backend.NET
- BackendGo
- BackendMost requestedNode.js
- MessagingKafka
- MessagingRabbitMQ
- PlatformsMost requestedStripe
- MessagingSQS
- MessagingWebhooks
- PlatformsSalesforce
- PlatformsHubSpot
- PlatformsXero
- SecurityOAuth 2.0
- SecurityAPI keys
- SecuritymTLS
- QualityPostman
- QualityPact
- QualitySentry
What’s included
What you get
Everything in scope, from mapping your systems to integrations running in production.
01StartSystem mapping
We map your systems, data and who needs what, where.
Read more +Show less −
System mapping is a short review of your systems and data that shows what needs to connect, in which direction and how often. You get a data map, an integration plan and a fixed quote. It usually takes 1–2 weeks.
What you get
- Data map of every system, its key records and owner
- List of each integration job and how often it runs
- Review of each system's API and its documentation quality
- Integration plan with order of work and risks
- Fixed, itemised quote for the build
How it works
- Workshops with the people who use each system
- We review APIs, exports and existing connections
- We agree which system holds the master copy of each record
- You approve the plan and the fixed quote
Good to know: Decide early which system is the master for customers, products and invoices; unclear ownership is the main cause of duplicate data.
02DesignAPI design
Clear, versioned API designs agreed before any code.
Read more +Show less −
API design is where we agree exactly how your API will work before any code is written. You get an OpenAPI specification, an authentication design and a versioning plan that your team and partners can review. Design usually takes 1–2 weeks, depending on the number of endpoints.
What you get
- OpenAPI specification for every endpoint
- Example requests and responses for each endpoint
- Authentication design using OAuth 2.0, API keys or mTLS
- Versioning plan so changes do not break existing users
- Error format and rate limit rules agreed in writing
How it works
- We list who will use the API and what they need
- We draft the specification and share it for review
- Partners or your team test against a mock version
- You sign off the design before the build starts
Good to know: Share the draft specification with any partner who will use the API, as their feedback is cheaper to act on now than after launch.
03BuildAPI build
Fast, secure APIs with tests on every endpoint.
Read more +Show less −
API build is the development of your API, in REST or GraphQL, from the agreed design. You get a fast, secure API with automated tests on every endpoint, rate limits and logging. We build in two-week sprints, each ending with a live demo.
What you get
- Working API in REST or GraphQL, matching the agreed specification
- Automated tests on every endpoint, run on each change
- Rate limits to protect the API from overload
- Authentication and permission checks on every request
- Load test results before launch
- Code in your repository from day one
How it works
- We build endpoints sprint by sprint from the specification
- Each change runs the full test suite automatically
- Load and security checks before release
- Release to a staging environment, then to live
Good to know: Ask for a staging environment that partners can use, so they can test against the API before it goes live.
04BuildIntegrations
Two-way syncs with your CRM, finance, payments and partners.
Read more +Show less −
Integrations are two-way syncs that keep your CRM, finance, payments and partner systems up to date with each other automatically. We connect tools such as Salesforce, HubSpot, Xero and Stripe through APIs and webhooks, with retries when a system is unavailable. A typical project runs 3–10 weeks, depending on the number of systems.
What you get
- Two-way syncs between your agreed systems
- Field-by-field data mapping, agreed and documented
- Webhooks for near real-time updates where systems support them
- Automatic retries and a queue for failed records
- Checks that compare record counts between systems
- Plan for a safe cut-over from the old process
How it works
- We agree the data mapping and the rules for conflicts
- We build and test each sync on test accounts
- Data checks on a copy of your real records
- Cut-over at a quiet time, with the old process as fallback
Good to know: Clean up duplicate and outdated records before the first sync, otherwise the integration copies the mess into every system.
05LaunchDocs & monitoring
Developer docs, alerts and sync health dashboards.
Read more +Show less −
Docs and monitoring make your APIs and integrations easy to use and quick to fix. You get developer documentation, alerts when a sync fails and dashboards that show sync health at a glance. Everything is in place before launch, so issues are caught from the first day.
What you get
- Developer portal with guides and endpoint reference
- Postman collection for testing each endpoint
- Alerts when a sync fails or slows down
- Dashboards showing sync volume, errors and response times
- Error tracking in Sentry with request details
- Runbook explaining how to fix common failures
How it works
- We write docs alongside the build, not after it
- We set up alerts and agree who receives them
- We review dashboards with your team before launch
- Monitoring can continue under a support plan
Good to know: Name one person on your side to receive sync alerts, so failures are never left waiting in a shared inbox.
How it works
From idea to launch
Every service runs through the same five steps. Here is what each one means for API & integrations.
01of 05
UnderstandWeek 1Once
We map your systems, data and the jobs each integration must do.
You getIntegration brief
What we do
- Workshop with your tech and ops teams
- Map systems, data and owners
- Agree the integrations that matter most
You get
- Integration brief
- Data map
- Priority list
From you
- 2 hours for workshops
- API access to current systems
Tools
- Miro
- Notion
02of 05
PlanBefore any codeOnce
API design, security plan and a fixed quote you approve.
You getFixed quote & timeline
What we do
- API contracts and data mapping
- Security and access design
- Error and retry plan
You get
- Fixed, itemised quote
- OpenAPI specification
- Timeline with milestones
From you
- Review and approve the plan
Tools
- Stoplight
- Jira
03of 05
BuildTwo-week sprints↻ Repeats
APIs and integrations built and tested sprint by sprint.
You getWorking endpoints every sprint
What we do
- Endpoints and integrations
- Automated contract tests
- Code review on every change
You get
- Working endpoints every two weeks
- Test environment
- Access to your code repository
From you
- 30-minute demo every two weeks
- Test accounts for partner systems
Tools
- Node.js
- Postman
- GitHub
04of 05
Test & launchEach release↻ Repeats
Load, security and data checks, then a safe cut-over.
You getLive integrations
What we do
- Load and security testing
- Data accuracy checks
- Cut-over with rollback ready
You get
- Live integrations
- Developer documentation
- Runbooks and handover
From you
- Go-live sign-off
Tools
- k6
- Sentry
05of 05
Support & growAfter launch↻ Repeats
Monitoring, fixes and new integrations as you grow.
You getOngoing improvements
What we do
- Sync and error monitoring
- Updates when partner APIs change
- New integrations
You get
- Monthly update
- Sync health report
From you
- Monthly 30-minute review
Tools
- Grafana
- Sentry
FAQ
API & integrations questions
What is an API integration?
A connection that lets two systems share data automatically, for example sending new Shopify orders to Xero or syncing contacts between your website and CRM.
How long does an integration take?
Most of our API projects take 3–10 weeks, depending on the number of systems, the quality of their documentation and how much data needs migrating.
Can you integrate systems that have no API?
Often yes, through database connections, file exchanges or secure screen automation. We assess feasibility during discovery.
Which systems do you integrate?
Common ones: Xero, Sage, QuickBooks, HubSpot, Salesforce, Shopify, Stripe, Microsoft 365 and Google Workspace, plus custom and legacy systems.
What happens if an integration fails?
We build retries, logging and alerts, so failures are caught and fixed quickly, and monitoring can continue under a support plan.
REST or GraphQL?
We build and consume both, and webhooks too. We choose based on the systems involved and document every endpoint for your team.
Who owns the code?
You do. All IP is assigned to you in the contract, and the code, accounts and documentation are yours from the first sprint.
Let’s talk
Let’s talk
A 30-minute call with an engineer and a clear next step for your project.