Information security for software delivery

ISO/IEC 27001
ISO/IEC 27001 certified
The contract
What makes an interface safe to build on
These are the parts a consumer depends on. The drawing exists to show that the endpoint is the smallest of them; the promises around it are what turn code into an interface.
01
A documented contract
The shapes, the errors and the guarantees, written down and testable, not discovered by a consumer at runtime.
- Schema
- Docs
02
Authentication and limits
Who may call, how often, and what happens when they exceed it — decided before a partner finds the edge.
- Auth
- Rate limits
03
Versioning
A way to change the API without changing the version a consumer already calls. This is the part that is missing when an API ages badly.
- v1
- v2
04
Deprecation
A clear, dated path to retire an old version, communicated in advance, so a sunset is a plan rather than a surprise outage.
- Notices
- Sunset
The internal-to-external jump
An internal API becoming a partner API is not a config change; it needs the contract, the auth model and the deprecation policy an outsider can rely on. We treat that jump as its own piece of work.
The first version of an API is easy; the tenth change to it, without breaking anyone, is the job.
Why APIs age badly
The change you could not make
An API without a versioning strategy is fine until the day you need to change it and cannot, because three teams and a partner call the current shape and any change breaks them. From that point every improvement is a negotiation, and the API calcifies around decisions made when it had no consumers. The cost of skipping versioning is not paid at launch; it is paid every quarter after.
So we design the contract and the versioning before the first endpoint, and we treat documentation and a sandbox as part of the deliverable rather than an afterthought. An API a partner can integrate against by reading, without a call, is worth more than one that is marginally faster but needs a meeting to understand.
What ships with the API
The parts that are not the endpoints
An endpoint that works is a quarter of an API. These are the rest, and skipping them is what turns an interface into a support burden.
The contract and its documentation
- Schema
- Reference docs
- Change log
- Examples
The safety controls
- Authentication
- Authorisation
- Rate limits
- Idempotency
The consumer experience
- Sandbox
- Error semantics
- Pagination
- Webhooks
The operational view
- Usage metrics
- Deprecation notices
- Status page
- Versioned releases
Our role
What we design and what you own after
- 01
Contract before code
We design and review the contract, the versioning and the deprecation policy before endpoints are built, because these are expensive to add once consumers exist.
- 02
Documentation as a deliverable
The reference, the examples and a sandbox ship with the API, so a consumer integrates by reading rather than by booking time with your team.
- 03
An API your team evolves
We leave the versioning discipline and the tooling so your team can change the API safely without us, because an interface only we can evolve is a bottleneck with a logo.
Which consumers the API is promised to, and how long a version is supported, are your commercial decisions; we build the contract, the versioning and the docs that let you keep those promises without freezing the API.
Common questions
What buyers ask
Do we really need versioning for an internal API?+
Lighter, but not none. Even internal, the moment a second team depends on the shape you have a coordination problem: a change on your side becomes a scheduling problem on theirs. Internal APIs can use a looser policy than partner ones, but the discipline of not silently breaking a consumer applies the same. The APIs that become painful are almost always the ones that started internal and grew consumers nobody planned for.
Can you turn our internal API into one partners can use?+
Yes, and it is a real project rather than a switch. An internal API usually assumes a trusted caller, informal error handling and no rate limits — all fine inside your own systems and dangerous once an outsider depends on it. We treat the jump as its own work: a hardened auth model, a documented contract, rate limits, a sandbox and a deprecation policy. Skipping that and simply exposing the internal API is how a partner integration becomes a support queue.
REST, GraphQL, or something else — how do you choose?+
By the consumer, not by fashion. REST is the safe default for a partner-facing API because the tooling and expectations are universal and it is easy to document. GraphQL earns its place when consumers need to shape varied queries over a rich graph, typically a first-party front end rather than an external partner. The wrong reason to choose either is that it is current; the right reason is which one the people building on it will find easiest to depend on.
In this cluster
Next step
Map it to your systems
A design review of the contract before the first endpoint is built, so versioning and deprecation are decisions rather than regrets.
Map it to your systems
What happens next
- 1We reply within one business day.
- 2A 30-minute scoping call with a senior consultant.
- 3A written proposal with scope, team, and timeline.
Or reach us directly
