Hire API developers who plan for the other side changing
Our engineers have integrated a UK government compliance API, two-way calendar sync and payment rails, and stayed on to watch them after launch. You interview them before anyone starts.
What you are getting
4 things that decide this
- 01Senior engineers only, each with integrations already running in production for named clients you can read about on this site.
- 02You interview every engineer before they join, so nobody is assigned to your team from a profile you never saw.
- 03They design for a vendor changing its contract: versioned calls, retries, and alerts on silence rather than only on errors.
- 04If the fit is wrong, say so and we replace the engineer. Every line they write is yours from the first commit.
What an API developer actually does here
Very little of this job is calling an endpoint and mapping fields. Most of it is deciding what happens when the other side misbehaves.
On Shift Link they wired in the UK government's Right-to-Work API. It checks documents and tracks expiry during worker onboarding, which cut manual compliance verification 70%. On Lexpair they built two-way sync against Google Calendar and Outlook Calendar, alongside Stripe payments and Twilio and SendGrid messaging. A lawyer's calendar and the platform never disagree about a booking. On Maidily they connected Stripe, Square, Twilio and QuickBooks into one platform for cleaning businesses, with Zapier open for whatever the client adds next.
A government API, two calendar providers and a payments stack are three different failure modes. The skill that repeats is noticing when one has started failing quietly.
What they have connected
Counted, not estimated
70%
less manual compliance verification, after wiring in the UK Right-to-Work API for Shift Link
2
calendar providers kept in sync at once for Lexpair: Google Calendar and Outlook Calendar
5
named services behind one Maidily platform: Stripe, Square, Twilio, QuickBooks, Zapier
What they take off your roadmap
Integrations that assume the vendor will change
Version pinning where the vendor supports it, and an alert when a response shape changes instead of a silent break in production.
Retries that cannot double-charge or double-book
Every operation carries a key the receiving side remembers, so a retried request returns the first result instead of creating a second one.
Knowing when to poll and when to trust a webhook
A webhook that can silently stop arriving gets a polling backstop. Payload verification runs before anything is written, on every inbound call.
A paper trail for the day a vendor breaks contract
Every request and response logged with enough detail to show a vendor exactly what changed, and when, rather than arguing from memory.
- Scoping callFree. What needs to talk to what
- ShortlistEngineers matched to the work
- You interviewYour process, your bar
- EmbedYour repo, standups, tools
- ReviewSwap if the fit is wrong
The interview is yours. A marketplace that assigns a vetted profile is skipping the only step that predicts fit.
Integrations we built and kept watching
How hiring works
- 01
Tell us what is stuck
A free call about the systems, the vendor's API and the deadline. If the integration is simpler than you think, you will hear that on the call.
- 02
Meet the engineers
We shortlist people who have integrated against a similarly awkward API, and you interview them. Say no and we go back to the shortlist.
- 03
They embed
Your repo, your standups, your ticket system. One of our engineers owns the integration and is named as the person accountable for it.
- 04
They hand over
Documentation, the retry and reconciliation logic, and someone on your team trained to run it. Where a client would rather we kept watching it, we do that under a service level we agree. The first 2 months of support and maintenance are free, with every build.
Stack
Verified in production
Messaging and workflow
How they build them
Tell us which systems stopped talking
Bring the API, the last time it worked, and what changed. The scoping call is free, and you will leave it knowing whether this is a quick fix or a design problem.
01How is this different from a freelancer or a job board hire?
You get an engineer who has already shipped integrations to production, plus a company accountable if one breaks. A job board hands you a candidate and a hiring risk you carry alone. If our engineer is not right, we replace them, which is not a conversation you can have with a contractor you found yourself.
02Can we swap the engineer if the integration work changes shape?
Say the word and we swap them out. You interviewed them, so this is rare, and it stays our problem rather than becoming a hiring cycle you have to run again.
03How much overlap do we get with our working day?
A daily overlap with your hours, fixed before anyone starts. Standups and debugging a broken sync happen while both sides are awake, because it is a conversation rather than a ticket. We agree the window during scoping and it does not move without you.
04Who owns the integration code and the credentials?
All of it is yours from the first commit. Credentials live in an encrypted store, scoped to the narrowest permission that does the job. They never sit in the codebase, and you can rotate them without a redeploy.
05What actually drives the cost of an integration build?
How many systems are involved, how good their documentation is, and how bad a silent failure would be for you. A well-documented API with webhooks is quick. A vendor with no API and a nightly file drop is not. Scoping calls are free. Where we have to get into an existing codebase before answering, a paid two-week diagnostic produces a fixed price rather than a guess.
Read next
- connecting the systems you already run →Us owning the integration outright.
- connecting an AI agent to your CRM →The same reliability problem, one layer up.
- backend developers for the systems behind the API →For work that goes beyond the integration layer.
- what a webhook actually is →The mechanism behind most of these builds.
