Software Development

API development designed contract first so integrators stop guessing

An API is a promise about behaviour that other people build businesses on. We design the promise first, write it down in a machine readable contract, and only then build the thing behind it.

What is API development?

API Development is designing and building the programmatic interface other software uses to reach your data and services, including the contract, authentication, rate limiting, versioning, documentation and client libraries. It suits Australian organisations exposing services to partners, connecting internal systems, or supporting their own mobile and web clients from one backend.

Get a fixed written quote
Typical timeline
6 to 14 weeks
What drives cost
The number of resources and operations, the complexity of the systems the API sits in front of.
Best for
Partner integrations, internal system connections and multi client backends
You own
The specification, the implementation, the gateway configuration and the SDKs
Built with
REST, GraphQL, OpenAPI, OAuth 2.0, contract testing
The sequenceRequest reaches the gatewayToken checked and scopedRate limit applied per clientHandler reads or writes dataResponse logged and traced
Versioning and deprecation dates are published, so integrators are never surprised.

Your handover

Why we write the contract before the implementation

An API written by exposing whatever the database happens to contain is an API shaped by an accident of history. Table names leak into resource names, internal status codes become public vocabulary, and the first integrator has to learn your schema to do anything useful. Worse, you can no longer refactor internally without breaking someone else's production system.

  1. 01OpenAPI or GraphQL schema agreed before build
  2. 02Implemented endpoints with contract tests in the pipeline
  3. 03OAuth 2.0 authentication with scoped, rotatable credentials
  4. 04Rate limiting, quotas and idempotency handling
  5. 05Versioning policy with published support windows
  6. 06Generated reference documentation and a getting started guide
  • Sandbox environment with seeded test data
  • Client libraries in your integrators' main languages
  • Monitoring, per client usage reporting and alerting
The rest of the answer

So our API development starts with an OpenAPI or GraphQL schema document written in plain terms that describe your business, agreed with the people who will consume it before code exists. That document is reviewable in an afternoon, whereas a built API is reviewable in a fortnight. From it we generate mock servers so a client team can start integrating while the backend is still being written, generate contract tests so the implementation cannot silently drift from the promise, and generate documentation that is always current because it comes from the same source. The contract also becomes the artefact you attach to a partner agreement, which matters when the integration is commercial rather than internal.

Versioning and deprecation without burning your partners

The moment a second organisation depends on your API, you have inherited an obligation. Breaking changes are not a technical event, they are a relationship event, and the partner who finds out through a failed overnight job will remember it. So we separate changes that are safe from changes that are not, and treat the difference as a rule rather than a judgement call.

The full list

Adding an optional field, adding an endpoint or adding an enum value that clients are told to tolerate are safe. Removing a field, renaming anything, tightening validation, changing a default or altering the meaning of an existing value are not. Breaking changes go into a new version, and the previous version stays available for a stated support window written into your terms rather than decided under pressure. We instrument the gateway so you know which clients are still calling the old version and can contact them by name instead of announcing a shutdown and hoping. Deprecation headers, a changelog and email notice before the sunset date cost very little and prevent the incident that damages a commercial relationship.

  • Versioning in the URL path or a header, chosen once and applied consistently
  • A written support window per version, published with the documentation
  • Per client usage visibility so you know exactly who is affected
  • Deprecation headers and a changelog integrators can subscribe to
  • Contract tests that fail the build when a change breaks the published schema

Choose the right level

REST, GraphQL or something else entirely

The choice is less ideological than the internet suggests. It follows from who consumes the API, how varied their data needs are, and how much caching infrastructure you want to lean on. Plenty of good systems use more than one style for different jobs.

Style

01

REST with OpenAPI

Works well when

Public and partner APIs, resource shaped data, caching matters

The trade off

Clients often make several calls to assemble one screen

02

GraphQL

Works well when

Many different clients with different data needs, deeply related data

The trade off

Caching and rate limiting are harder, and query cost needs active control

03

Webhooks and events

Works well when

The consumer needs to know when something changed rather than polling for it

The trade off

You must handle retries, ordering, duplicates and endpoint verification

04

Batch file exchange

Works well when

High volume nightly reconciliation with an established counterparty

The trade off

Latency measured in hours, and error handling that is entirely your problem

How we work this out during scoping

One practical note for Australian organisations integrating with government, banking or logistics counterparties: you often do not get a choice, because the other party has already decided and published a specification. In that case the work is building a resilient client with sensible retries, idempotency and good error surfacing, which is a different and frequently underestimated project.

Authentication, rate limits and the abuse you should expect

Any API reachable from the internet will be probed within days. The controls are well understood and the failures come from skipping them rather than from anything exotic. We use OAuth 2.0 client credentials for machine to machine access and authorisation code with PKCE for user facing clients, scope tokens to the minimum permissions each integration needs, and keep credentials rotatable so a leaked key is a five minute fix rather than an incident.

Rate limiting protects both sides

Rate limiting protects both sides. It stops one enthusiastic integrator from degrading service for everyone, and it gives you a commercial lever if you sell tiered access. Limits are applied per client with clear headers telling the caller their remaining quota and when it resets, because a limit that returns a bare error teaches integrators nothing except to retry harder. We add idempotency keys on anything that creates or charges, so a network timeout followed by a retry does not produce two orders. Payload size caps, request timeouts, structured audit logging and alerting on unusual patterns round it out. Where the API carries personal information, the Privacy Act 1988 obligations apply to it exactly as they do to your website.

Documentation, sandboxes and getting an integrator productive

The real measure of API development is how long it takes a developer who has never seen it to make a successful authenticated call. If that is under fifteen minutes you will get integrations. If it takes two days and an email to your support desk, partners quietly deprioritise you and the integration never ships.

More on documentation, sandboxes and getting an integrator productive

So documentation is treated as part of the deliverable rather than an afterthought. Generated reference from the contract, a getting started guide with a real worked example, copy and paste requests, plain language explanations of the error codes and what to do about each one, and a sandbox environment with seeded test data that behaves like production including its failure modes. Where volumes justify it we generate typed client libraries in the languages your integrators actually use, which removes a whole category of avoidable support questions. If the API supports your own applications as well, this same documentation is what stops your mobile team and your web application team implementing the same rules two different ways.

When you do not need to build an API

A public API is a product with its own support obligations, documentation debt and backwards compatibility burden. If nobody has asked for one, speculative API development is a cost with no counterparty. Wait for the second or third partner to ask for the same thing.

The rest of the answer

If the goal is connecting two systems you already run, an integration platform is often faster and cheaper than building and hosting an interface. Tools covered in n8n automation or Zapier automation handle a great many system-to-system flows without a custom build, and the honest recommendation for a modest volume connection is usually one of those. If the aim is a single nightly data export to a reporting tool, a scheduled file drop is more robust than a live interface and nobody has to be on call for it. Build an API when there will be multiple consumers, when the data must be current rather than daily, or when the interface itself is part of what you sell. Suppliers and distributors moving toward the last of these usually pair it with a supplier portal so partners without developers are not excluded.

How we scope it

Four ways to scope your API Development project

We do not publish package prices, because the same brief can be a short build or a long one. These are the shapes the work usually takes. Tell us which one sounds like you and you will get a fixed written quote that spells out exactly what it covers.

API Discovery build

A scoped build with the architecture settled first

Fixed written quote, agreed before work starts

  • OpenAPI or GraphQL schema agreed before build
  • Implemented endpoints with contract tests in the pipeline
  • OAuth 2.0 authentication with scoped, rotatable credentials
Request a quote
Most common

API Product build

A working product your customers or staff use daily

Fixed written quote, agreed before work starts

  • Everything in API Discovery build
  • Rate limiting, quotas and idempotency handling
  • Versioning policy with published support windows
  • Generated reference documentation and a getting started guide
Request a quote

API Platform build

A platform with SSO, audit trails and a security review

Fixed written quote, agreed before work starts

  • Everything in API Product build
  • Sandbox environment with seeded test data
  • Client libraries in your integrators' main languages
  • Monitoring, per client usage reporting and alerting
Request a quote

API Product care

A named engineer, a roadmap and real service levels

Rolling monthly, quoted in writing

  • A named engineer rather than a ticket queue
  • A roadmap you set, worked through each month
  • Dependency patching, monitoring and incident response
  • Rolling, cancel with 30 days notice
Request a quote

These are shapes, not menus. Most quotes end up somewhere between two of them, and we will say so when the honest answer is the smallest one. Describe the problem and we will tell you which it is.

Questions buyers usually ask

Frequently asked questions

Working with us

Can you build an API on top of a legacy system we cannot replace?

This is common and often the smartest option available. We put a modern interface in front of the old system, isolate its quirks behind a clean contract, and add caching where the legacy database cannot handle the load. It also creates a migration path, since you can later replace what sits behind the API without every consumer needing to change.

Can you integrate us with an existing third party API instead?

Yes, and roughly half of this work is client-side. We build integrations against freight carriers, accounting platforms, payment providers, government services and industry systems. The care goes into retries with backoff, idempotency, handling partial failures, and surfacing errors to your staff in language they can act on rather than logging a status code and moving on.

Detail and edge cases

How long does it take to build an API?

Most projects run 6 to 14 weeks. Contract design takes the first week or two and is where the value concentrates. Implementation depends on how many resources are exposed and how tangled the systems behind them are. Legacy databases with inconsistent data add time, because the API has to present something coherent to callers regardless of what is underneath it.

What affects the cost of API development?

The number of resources and operations, the complexity of the systems the API sits in front of, whether you need a sandbox and generated client libraries, and the level of security and audit required. Partner facing APIs cost more than internal ones because documentation, versioning and support tooling all become real requirements. We quote in writing after the contract design stage.

Do we own the API and its documentation?

Yes. The specification, implementation, gateway configuration, documentation site and any generated SDKs are yours, in repositories under your control. Cloud and gateway accounts are in your business name. Because the contract is written down in a standard format, another team can maintain the API without needing to reverse engineer its intended behaviour from the code.

How do you make sure the API stays fast under load?

We set target response times per endpoint at design stage and test against them with realistic data volumes rather than an empty database. Common measures include database indexing tuned to actual query patterns, response caching with sensible invalidation, pagination enforced by default and expensive operations moved to background jobs with a status endpoint. Monitoring then reports real latency percentiles so regressions surface quickly.

Send us the integration problem

Tell us who needs to call what, and how current the data has to be. We reply within one business day with a proposed contract shape and a fixed written quote.