What we do
Tools
Industries
Department
How we workLet's talk →
Home/API Developer
API Development

Hiring an API Developer? First Decide Whether You're Building an API or Connecting to One

Two different jobs hide behind the same search. One is getting systems you already use, like your CRM, store or accounting, to pass data through the APIs they already have. The other is building an API of your own that customers, partners or an app will call for years. The second is the harder hire, because every choice in version one becomes something other people's software relies on.

Which job is yours

Connecting systems you already have? That's integration work: reading and writing other companies' APIs, living within their limits, handling their webhooks, and fixing records when a sync fails. It's most of what people mean when they say they need an API developer, and it's the core of what n-frames does: we build and look after these integrations, including retries, webhook handling and repairing records when a sync fails.

Opening your own data or service to others? That's API design: endpoints, authentication, versioning, rate limits and documentation that outside developers build against.

Both at once is common. A portal for your clients might expose an API of your own while pulling invoices from your accounting system behind the scenes.

Who will call your API decides how much of it you need

Public, partner and internal APIs need very different amounts of security, documentation and limits. Scoping to the real audience is where most of the cost difference sits.

Who calls it What it needs Where over- or under-building shows
Only your own web or mobile app Clear endpoints, login, a permission check on every request, and tests. Versioning can stay light because you ship both sides. Mobile breaks that rule. Old app versions stay on phones for months, so the API has to keep answering them.
A handful of partners or suppliers Separate API keys or OAuth clients per partner, logs of who called what, written docs and a test environment they can try things in. Partners build against whatever you send on day one. Changing it later becomes a project on their side, not just yours.
Any developer who signs up (a public API) Self-serve keys, rate limits that answer with HTTP 429 and a retry time, a published changelog, versioning, and docs good enough that nobody has to email you. Building all of this for an internal tool wastes months. Skipping it on a public API means support tickets forever.
Other systems receiving events from yours (webhooks) Signed payloads, retries with backoff, and a way for receivers to replay what they missed. Receivers will get duplicates. Send an event ID with each one so they can ignore repeats.

Small API changes that break the software calling it

None of these look dangerous in a code review. Each one breaks somebody's integration the morning it ships.

Renaming a field, or changing its type

How you'll know: A partner's import fails because customerId is now customer_id, or a number now arrives as text.

Fix: Add the new field alongside the old one, mark the old one deprecated in the docs and changelog, and remove it only in a new version once callers have moved.

Making an optional field required

How you'll know: Requests that worked yesterday come back as validation errors today.

Fix: New requirements belong in a new version, or get a sensible default so existing callers keep working.

Changing what an error looks like

How you'll know: Callers retry forever, or never, because the status code or error shape they check for has changed.

Fix: Pick one error format early and document every code. Treat a change to it like any other breaking change.

Adding a new value to a list callers act on

How you'll know: A new order status falls through a partner's code, and their system quietly stops processing those orders.

Fix: Say in the docs from the start that new values may appear, and announce each one before it goes live.

Tightening a limit or changing the page size

How you'll know: A nightly sync that used to get 500 records a page now gets 100 and silently misses the rest.

Fix: Announce limit changes in advance, return paging details in every response, and test how existing callers behave before rolling it out.

Docs, keys and the long tail of version one

Documentation that's slightly wrong is worse than none, because the developer on the other end trusts it and builds on the wrong assumption. The way to keep it honest is to describe the API once, usually as an OpenAPI file, then test the code against that description and generate the reference docs from it. When the code drifts, a test fails instead of a partner.

Keys leak and staff leave, so plan from the start to issue new credentials and retire old ones without downtime. Behind the API there's usually a server side and a database doing the real work. If that part is bigger than the interface, see backend developer, and if the data model is the hard part, database developer.

Questions people ask

Do you design the API from scratch or build to a spec we already have?

Either. Given a spec, we build to it and flag anything likely to hurt later, like no pagination or no plan for versions. Without one, we design it with you, starting from who will call it and what they need back.

Can you take over an existing API that other systems already depend on?

Yes, carefully. We start from the logs: which clients call which endpoints, how often and with what. That map decides what can change freely and what needs a new version, because breaking an API other systems rely on costs far more than breaking a standalone feature.

Is this the same as integration work?

Related, but not the same. Building an API means designing something others will depend on. Integration work means using someone else's, like the HubSpot API or the Stripe API. Many projects need both, and n-frames builds either one. If the job is mostly automating work between tools you already own, automation engineer covers that side in more depth.

REST, GraphQL or something else?

REST suits most business APIs and is what partners expect to see. GraphQL earns its place when many different screens need different slices of the same data. Choose for the people who'll call it rather than for what's fashionable.

How should an API handle versions?

Most business APIs put the major version in the address, such as /v1/, and only raise it for breaking changes. Additive changes, like a new optional field, ship without a new version. Whatever scheme you pick, publish a changelog and a retirement date before anything is removed.

What if the API is part of a whole new product?

Then the API is one piece of a bigger build: screens, a database, billing and the systems it connects to. That's custom software development, and the API design still comes first, because everything else is built against it.

Let's talk

Tell us the one thing your team does manually that eats up time. We read every message and reply within a day.