Integrations that hold
when the other side fails.
Payments, ERP, CRM, shipping, accounting, and whatever else your business runs on top of. Building the happy path takes an afternoon. Building the version that survives a duplicate webhook, an expired token and a partner outage is the actual job. Prepaid in Hour Blocks of 6, 12 or 24 hours.
Within two business days
Your message goes straight to the studio. No sales queue, no account manager in between.
Prepaid Hour Blocks
Buy 6, 12, or 24 hours up front at $30/hr. Unused hours never expire.
10 live products
Payment, market-data and LLM provider integrations live across our products, running right now.
You own the code
Full source, in your repository, with the reasoning written down. No lock-in to us or anyone else.
Where integrations
actually go wrong.
Six areas, each one a place we have watched a working integration quietly start losing data. The detail is here so you can tell the difference between someone who has shipped these and someone who has read about them.
Calling someone else's API
A typed client rather than HTTP calls sprinkled through controllers, with timeouts set deliberately instead of left at the library default, which is often infinite. Pagination handled as cursors where the provider offers them, because offset pagination silently skips records when the underlying data changes mid-walk. Rate limit headers respected before the provider has to enforce them with a 429, and every state-changing call carrying an idempotency key.
- One typed client per provider
- Explicit connect and read timeouts
- Cursor pagination over offset where offered
- Rate limit headers respected proactively
- Idempotency keys on state-changing calls
- Sandbox and production kept separate
Receiving webhooks safely
Inbound webhooks arrive twice, out of order, and occasionally from someone who is not the provider. Every endpoint verifies the signature before parsing the body, records the event identifier so a replay is a no-op, and acknowledges fast - doing real work inside the webhook request is how you end up on a provider's automatic disable list. The actual processing happens in a queued job where a slow step cannot cause a delivery timeout.
- Signature verification before parsing
- Processed event ledger for replay safety
- Fast acknowledge, queued processing
- Out-of-order event handling
- Raw payloads stored for replay and audit
- A manual replay tool for support
OAuth, tokens and secrets
OAuth 2.0 authorisation flows including the refresh path, which is where most integrations break at three in the morning six months after launch because nobody tested what happens when a refresh token is rotated or revoked. Tokens stored encrypted, refreshed before expiry rather than after a failure, and per-tenant where your product is multi-tenant. Secrets in environment variables or a secret store, never in the repository, with rotation written down as a procedure.
- Authorisation code and client credentials flows
- Refresh and rotation tested, not assumed
- Per-tenant credential storage
- Encrypted at rest, scoped as narrowly as possible
- Rotation as a documented procedure
- Clear failure when a connection is revoked
Two-way sync with ERP and CRM
Two-way synchronisation between your application and an ERP, CRM, accounting system or warehouse. The questions that decide whether it works are unglamorous: which side wins when both changed, how a record is matched when neither system shares an identifier, what happens to a record deleted on one side, and how you catch the drift that accumulates anyway. We answer those explicitly and write the answers down, rather than discovering them in production.
- Field mapping agreed and documented
- Explicit conflict resolution rules
- Stable cross-system identifiers
- Soft-delete and archival handling
- Nightly reconciliation that reports drift
- Backfill for historical records
Failure handling that is designed, not accidental
Every integration fails; the design decision is what failure looks like. Queued work with exponential backoff and jitter so a recovering partner is not hit by every retry at once. A circuit breaker so a dead provider stops consuming your workers. A dead-letter queue that preserves the payload so nothing is lost, and alerting on the queue depth rather than on individual errors, because the shape of the failure is what tells you whether it is a blip or an outage.
- Exponential backoff with jitter
- Circuit breaking on repeated provider failure
- Dead-letter queue preserving payloads
- Alerting on queue depth and age
- Correlation IDs across both systems' logs
- Graceful degradation in the user interface
When you are the API
Sometimes you are the provider: a partner needs to read your data, or you need to notify them when something changes. That means versioned endpoints so you can evolve without breaking them, authentication scoped to what each partner may see, rate limits that protect you, outbound webhooks with retries and a signature so they can verify you, and documentation generated from the code so it cannot drift.
- Versioned public endpoints
- Per-partner keys, scopes and quotas
- Signed outbound webhooks with retries
- Delivery log a partner can self-serve
- Generated, accurate documentation
- Deprecation path for old versions
What makes it maintainable.
An integration only one person understands is a liability with a deadline. Everything here exists to make sure that person does not have to be us.
A field mapping document
Which field on your side corresponds to which on theirs, with the transformations spelled out. This is the document your finance team will ask for eventually.
An event inventory
Every webhook and event type, marked as handled or deliberately ignored, with the reason. Silence about ignored events is where surprises come from.
A replay path
A documented way to re-run a failed message or backfill a date range, so a partner outage is recoverable by your team without a developer.
Tests against recorded responses
Integration tests that run against recorded provider responses, including the error cases, so your CI does not depend on a third party being up.
Alerts that mean something
Monitoring on queue depth, message age and reconciliation drift, with a note on what each alert means and what to do about it.
A support window
A short window after handover. If our integration caused it, fixing it is not billed as new hours.
Integrations running
on our products.
Client work stays under NDA, so what we show is what we run ourselves: real provider integrations where a failed webhook costs us money rather than a client.
LearnCoachAssist
Stripe subscriptions on Laravel 12: plans, renewals, failed payments and the webhook-driven state that decides whether an account still has access. The unglamorous half of billing, in production.
Read the case studyStockLrn
Live financial data, charts and analyst ratings pulled from third-party providers. Rate limits, stale-data handling and a user interface that has to stay honest when the upstream feed is late.
Read the case studyParley
A Laravel service brokering every model call for an AI coaching feature inside SignedDocsRepublic: keys kept server-side, provider calls rate-limited and cost-controlled, and failures degraded rather than exposed to the user.
Read the case studyAlso relevant: UslugeHR wires Stripe into a multi-role booking flow, and automated social publishing posts through the official platform APIs rather than by driving a browser.
Four steps, no discovery call
you have to sit through.
Tell us which two systems and which direction. Links to the partner documentation in your first message save hours of guessing.
Tell us the problem
A few sentences on what you have and what you need. Rough is fine - we ask the questions that matter and tell you honestly if it is not a fit.
Pick an Hour Block
Prepay a block of hours - 6, 12, or 24. The block is the budget: we work until it is used, or you top up.
Work in the open
One end-to-end path first against the sandbox, including the failure cases, then the remaining paths against that proven shape.
Handover and support
You get the code, the field mapping, the event inventory, the replay procedure and a short support window.
Bought in
prepaid Hour Blocks.
No volume games and no agency margin on top. You buy the block of hours that fits the size of the job, so you know the number before we start rather than after.
Typically enough for a focused fix, a small feature, or an integration you are stuck on.
Start with StarterTypically enough for a working prototype, or one well-scoped feature built and shipped.
Start with StandardTypically enough for a larger build with integrations, auth, or billing wired in.
Start with ProEvery Hour Block is hours at $30/hr with no discount. It is a bucket of time, not a fixed-scope deliverable. Unused hours do not expire - roll them into the same project or a later top-up. If the work runs long, you buy another block; nothing is billed without you agreeing to it first.
Frequently asked.
We already tried this and it half works. Can you finish it?
Usually yes, and it is a common starting point. Most half-finished integrations work on the happy path and fall apart on the boring edges: a duplicate webhook, a token that expired at three in the morning, a partner returning a 500 mid-batch. Those edges are where most of the real work is, and they are exactly what we are being hired for.
What is an Hour Block, and what if the job takes more or fewer hours?
An Hour Block is a prepaid block of hours: Starter is 6 hours for $180, Standard is 12 hours for $360, Pro is 24 hours for $720. It is a bucket of time, not a fixed-scope deliverable. Unused hours do not expire and roll into the same project or a top-up. If the work runs over, you buy another block, and nothing gets billed without you agreeing to it first.
What if the partner has no API, only a CSV export?
That is still an integration, just an uglier one. A scheduled file drop over SFTP, an emailed export, or a flat file on a shared folder can all be automated with the same care: validation on arrival, a quarantine for malformed rows, idempotent import so re-processing the same file is harmless, and an alert when the file simply does not arrive.
How do you stop duplicate charges and duplicate records?
Idempotency keys on every outbound call that changes something, and a record of processed event identifiers on every inbound webhook. Providers retry deliveries, networks time out after the remote side already succeeded, and queues occasionally deliver twice. The only safe assumption is that every message arrives more than once, so every handler is written to make that harmless.
What happens when the other system is down?
Nothing user-visible, if the integration is built right. Outbound calls that are not needed for the current page go into a queue, retried with exponential backoff and jitter so a recovering partner does not get a thundering herd. After a threshold the work lands in a dead-letter queue with the payload preserved so it can be replayed once the partner is healthy, and a human gets told rather than finding out from a customer.
How do you handle credentials and secrets?
They never go in the repository. Credentials live in environment variables or your secret store, sandbox and production are kept separate, inbound webhooks are verified by signature rather than trusted because they arrived, and rotating a key is a documented procedure rather than an outage. If we need access to a provider account, we ask for a scoped key and prefer you revoke it when the work is done.
Can you document it for our team?
Yes, and it is part of the deliverable rather than an upsell. You get a field mapping between the two systems, the list of events handled and ignored, how to replay a failed message, what each alert means, and what to check first when the sync looks wrong. That document is what stops the integration becoming something only we understand.
How do we start?
Send a few sentences through the form on this page: which two systems, which direction the data flows, and how fresh it needs to be. Links to the partner API documentation help. You get a reply from us directly, usually within two business days.
Tell us which systems need to talk.
Which two systems, which direction the data flows, and how fresh it needs to be. A few sentences is plenty - we read every message and reply within two business days with an honest read and the Hour Block that fits.
Prefer email?
[email protected]