Skip to main content

Service

API Integration

Connect your website or application to the third-party services and internal systems it depends on.

What this service covers

Most useful software sits on top of other software. Payments, messaging, maps, stock, accounting and identity are all provided by someone else, and your product works only as well as those connections.

Integration work is less visible than design or development and causes more trouble when it is done badly. A connection that silently fails, silently rate-limits or silently drifts out of date causes real operational problems.

Why it matters

Problems this solves

All of these are the same problem in different clothing: there is no single trustworthy path for data to move between systems.

  • Data is copied between systems by hand

    Someone exports a spreadsheet and re-enters it, every day. It is slow, and the copies slowly stop matching.

  • Two systems disagree

    The same record exists in two places with different values, and nobody can say which is correct.

  • No single source of truth

    Reports have to be assembled from several exports before they can be trusted, and that assembly takes hours.

  • Failures are invisible

    A connection breaks and nothing tells anyone until a customer complains or a month-end goes wrong.

  • Integrations break without warning

    A provider changes their API, requests start failing, and nothing was in place to notice or explain why.

  • Credentials are handled loosely

    Keys stored in places they should not be, or shared by email, which is a risk long before it is an incident.

Scope

What you receive

Scope covers the connections named in the integration map. Discovering a further dependency mid-build is a change request, not a surprise.

  • A map of every system involved and what moves between them
  • Agreed contracts for each connection, including what happens when a call fails
  • A documented approach to credentials and where they are held
  • Error handling with retry, backoff and clear failure states
  • Logging and monitoring so a broken connection is noticed and diagnosable
  • Rate limit and pagination handling for providers that need it
  • Test coverage against each provider's sandbox where available
  • Written documentation for the integration and who can change it

Capabilities

Features and options

Patterns are chosen per provider. A payment API and an internal database integration fail in different ways, and are not built the same way.

  • REST and GraphQL consumption

    Working with the provider's actual protocol, including authentication and pagination conventions.

  • Webhooks

    Inbound events handled, verified and made idempotent, so a repeated delivery cannot double-process.

  • Authentication

    OAuth, API keys or tokens handled correctly, rotated on a schedule and kept out of source control.

  • Payload mapping

    Translating between how the provider describes something and how your system describes it, kept in one place.

  • Resilience

    Retries with backoff, circuit breaking and caching, so a provider outage does not take your product down with it.

  • Monitoring

    Health checks and alerting that tell you a connection has degraded before users report it.

Process

How a project runs

Discovery here means finding every system a product touches, including the ones nobody mentions because they seem obvious. Connections discovered late are the usual cause of integration projects overrunning.

  1. Discovery
  2. Planning
  3. UI/UX
  4. Development
  5. Testing
  6. Deployment and maintenance

Technology

Chosen to fit the requirement

Technology decisions follow the problem being solved. Where a requirement has a trade-off, we explain the options rather than choosing silently.

Questions

Frequently asked

Questions we are commonly asked about api integration.

Ask something else
Which providers can you work with?

We work with anything that exposes a documented API, file exchange or accessible database, which covers most established services. The constraint is the provider's own documentation and rate limits. Where a service has no integration route at all, we will say so early.

Can you integrate with a system we already run internally?

Often, yes. A legacy system may expose a database, a file format or an export rather than an API, which changes the approach and the effort involved. We investigate this during scoping so the estimate reflects reality rather than assumption.

What happens when a provider changes their API?

It happens, and the honest answer is that you cannot prevent it. What you can do is detect the breakage quickly and understand it when it occurs — which is why monitoring and logging are part of the deliverable rather than an optional extra. We also keep provider-specific behaviour isolated so a change touches one place.

How are API keys and credentials handled?

Secrets are held outside source control, scoped as narrowly as the provider allows, and rotated. Access is logged so it is clear who used a credential and when. Where a provider supports restricted keys, those are used rather than account-wide keys.

Do you maintain integrations after launch?

Yes, as a separate arrangement. Providers change their APIs and add deprecations, so integrations need periodic checking. We will set out what ongoing monitoring costs and recommend a review cycle appropriate to how critical each connection is to the business.

Related

Projects frequently draw on more than one service line.

Ready to discuss api integration?

Tell us what you have in mind and we will come back with questions, a recommended approach and a written scope. Call 94277 34998 if you would rather talk.