APIs & integrations

APIs and integrations that hold when things go wrong.

Clean interfaces between your product and everything it talks to: payment gateways, ERPs, CRMs, logistics, WhatsApp. Built so that a third party having a bad day does not become your outage.

What we build

Integration is easy on the happy path. Nobody lives there.

The first version of any integration works. It works because the network was up, the payload was well-formed and nothing was rate-limited. The interesting engineering starts the first time the other system returns a 502 halfway through a batch, or sends the same webhook twice, or quietly changes a field from a number to a string.

APIs somebody else can build against

If a partner needs a call with your developer to use your API, it is not finished. We ship an OpenAPI or GraphQL schema, real examples for every endpoint, consistent errors with useful messages, and a versioning policy so you can change things later without breaking whoever integrated last quarter. Authentication is API keys or OAuth 2.0, scoped per client.

The systems businesses actually run on

Stripe and local payment gateways. ERPs and accounting systems. CRMs and helpdesks. Shipping and logistics providers. WhatsApp Business and email. Each of these has its own idea of pagination, rate limits and what a webhook signature means, and getting those details right is most of the work in every integration project we have delivered.

Built for the failure modes

Retries with exponential backoff, idempotency keys so a repeated webhook cannot double-charge or double-ship, a queue so a slow partner does not block your request, and a dead-letter store for the ones that never succeed. Every integration gets a log you can search by order or customer, because "did it go through?" is the question you will be asked.

Legacy systems included

Not everything has a modern API. We have taken data out of systems whose only interface was a scheduled CSV drop or an emailed report, and wrapped them in something the rest of your stack can talk to normally. The wrapper is where the ugliness stays, so it does not spread.

What you get

  • Documented, versioned APIs your partners can build against alone
  • Payments, ERPs, CRMs, logistics and WhatsApp, connected properly
  • Retries, backoff and idempotency, so a bad partner day is not your outage
  • A searchable log per transaction, answering "did it go through?"
  • Webhook signature verification and replay protection
  • Sandbox credentials and a staging path, so nobody tests against live money

Stack we use

  • REST
  • GraphQL
  • OpenAPI
  • webhooks
  • OAuth 2.0
  • Stripe
  • Redis
  • Node.js

How it runs

Three shapes of this work.

Most projects are one of these, and some are all three.

01

Build an API

A public or partner-facing interface to your product: schema, docs, auth, rate limits, versioning and a sandbox to test against.

02

Connect two systems

Your product and a third party, in both directions, with retries, idempotency and a log that survives an audit.

03

Wrap something legacy

A system whose only interface is a CSV drop or an emailed report, given a normal API so the rest of your stack stays clean.

Questions

APIs & integrations, answered.

Can you integrate with a system that has no public API?

Often, yes. Options in order of preference: an undocumented but stable internal API, a scheduled file export, a database replica, and only as a last resort scraping a UI. We tell you upfront which one we are relying on and how fragile it is, because that determines what maintenance will cost.

What happens if the third-party service goes down?

Your side keeps working. Requests queue, retries back off, and the transaction lands when the other end recovers. Where a live response is genuinely required we fail with a clear message and a recorded intent to retry, rather than losing the request silently.

How do you stop duplicate webhooks causing duplicate charges?

Idempotency keys. Every incoming event carries an identifier we store; a repeat is recognised and acknowledged without re-running the effect. It is a small amount of work at build time and it is the difference between a clean ledger and a support queue full of double charges.

Do you provide API documentation?

Yes, and it is part of the deliverable rather than an extra. An OpenAPI or GraphQL schema, a working example per endpoint, error reference, and sandbox credentials. The test we hold ourselves to is that a competent developer can integrate without emailing us.

Who owns the API once it is built?

You do. It runs in your infrastructure, the code is in your repository, and the docs are yours to publish. There is no NASTACK gateway in the middle of your traffic.

Two systems that need to talk?
Let’s connect them.