Software & appsBuild
API development & integrations
Connections between the systems your business already uses, and APIs for your own applications. Which integrations are needed is defined during discovery and in the scope.
Connections that move information without retyping it.
-
API development
An API for your application, so other systems or partners can read or send data in an agreed format, with documentation they can work from.
-
API integrations
Connecting your website or application to third-party services through their APIs, so information entered once reaches the systems that need it.
-
Data exchange between systems
Keeping records in step between systems you already use, when something changes or on a schedule agreed in the scope.
-
Custom integrations
Where a ready-made connector doesn't do what you need, a small custom service that sits between your systems, where appropriate.
When connecting systems makes sense.
An integration makes sense when
- The same information is typed into more than one system.
- Inquiries or orders from your website need to reach the tools your team works in.
- Reports depend on exporting and combining files by hand.
- A partner or another system needs data from your application.
Map the data first, then connect.
Projects with significant uncertainty go through paid discovery first. Timeline depends on project scope and requirements.
See how we workDiscover
Your systems, the data, and what each API allows.
Notes and next steps
Scope
Data mapping, exclusions, timeline, and price, in writing.
Written scope and price
Build
Development and review on staging, where appropriate.
Working integration
Test and launch
Testing with test data, then go-live and checks on real data.
Handover documentation
Care
Updates when a connected service changes, as agreed.
Support, if you want it
Have systems that should talk to each other?
Book a discovery callWhat's included.
Discover
- The systems involved and the data that should move
- What each system's API allows
- Access needed to each system
Design
- Data mapping: which fields go where
- When data moves: on change or on a schedule
- What happens when a system doesn't respond
Build
- Development, reviewed on staging where appropriate
- An API for your application, where in scope
- Records of exchanges for troubleshooting, where in scope
Launch
- Testing with test data before production deployment
- Go-live and checks on real data
- Handover documentation
Chosen for the systems you connect, documented for your team.
Which services can be connected depends on what their APIs allow. This is checked during discovery, before the scope is agreed.
- Back end
- PHP, Laravel, Node.js, Go
- Databases
- MySQL, PostgreSQL
- Infrastructure
- Linux, Nginx, Docker, VPS
- Code
- Git, GitHub
What you receive.
What exists at the end of the project, and where it lives.
- A working integrationRunning in your environment, as agreed in the scope.
- An API for your application, where in scopeWith documentation your team or partners can use.
- Data mappingWhich data moves where, written down.
- Source code repositoryAccess as defined in the project agreement.
- Handover documentationAccess list, how it works, and how to change settings.
- Post-launch supportIncluded or provided separately, depending on the project agreement.
Data mapped in writing.
Which data moves, where, and when is part of the written scope. Changes to scope are agreed in writing first.
Reviewed and tested
Code review and testing before production deployment. Where appropriate, changes are reviewed on a staging environment first.
Ownership and rights
Ownership and rights to project deliverables are defined in the project agreement. Client-owned accounts and access are used where appropriate.
| Account | Owner |
|---|---|
| Third-party services | You |
| Code repository | You |
| Server or hosting | You |
What to know before you start.
Good to know
- An integration can only do what each service's API and terms allow.
- When a connected service changes its API, the integration may need updates.
- Data quality in the source systems affects the result.
Not included by default
- Third-party subscriptions and usage fees. Paid by you directly, with accounts in your name where appropriate.
- Changes inside third-party systems that we don't control.
- A full application with its own screens and user roles. See web application development.
Questions before you decide.
Can you connect the systems we already use?
Often, if each system offers an API or another supported way to exchange data. This is checked during discovery, before the scope is agreed.
Do I need an integration or a web application?
An integration connects systems you already have. If the process needs its own screens, user roles, and workflows, see web application development. Discovery helps decide.
Who pays for the third-party services?
You pay third-party services directly, with accounts in your name where appropriate.
What happens when a connected service changes its API?
The integration may need updates. Post-launch support can be included or provided separately, depending on the project agreement.
How long does it take?
Timeline depends on project scope and requirements. It is part of the written scope you agree before work starts.
Do I own the code?
Ownership and rights to project deliverables are defined in the project agreement. Client-owned accounts and access are used where appropriate. Open-source and third-party components remain subject to their own licenses.
Map the data first, then connect.
Tell us which systems need to work together.
We'll review your request and get back to you. Work starts after the scope and project terms are agreed in writing.