Platform API Design
Platform API design creates the programmatic interfaces that internal developer platforms expose to application teams. It balances abstraction level, discoverability, consistency, and evolvability so developers can self-serve infrastructure capabilities reliably.
itPlatform engineering and SRE | OpenSkills.info
Recommended first:platform-engineering-fundamentals
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic: Platform API Design
A platform API is the promise a platform makes when it offers a capability to people and automation. The HTTP path, CLI command, event, or configuration file is only the packaging. The actual promise is about what can exist, who owns it, what state it is in, and what happens when reality develops its usual interest in being inconvenient.
Start with the resource model. A managed database is not a create call wearing a database-shaped hat. It has an identity, an owner, a tenant, desired settings, observed status, credentials, readiness, updates, backups, and deletion. If those parts are vague, the API preserves the vagueness and distributes it to every portal, template, and script that has the poor fortune to consume it.
The useful split is between declarative and imperative interactions. Declarative APIs state what should exist and reconcile toward it. Imperative APIs request an action such as promote, rotate, or retry. Neither is morally superior. The question is whether the caller needs a lasting state or a recorded transition. A Boolean that secretly means "start the process" is where an innocent-looking field begins a small administrative coup.
Long-running work needs an operation resource. Return a durable handle, then show queued, running, succeeded, failed, or cancelled state. A request connection is not a workflow state store, even if it waits very earnestly. The same rule helps when a caller retries after a timeout or needs to understand a partial provider failure.
HTTP adds shared rules rather than decorative status numbers. Safe methods are read-only in their requested semantics. Idempotent methods can be repeated with the same intended effect. Preconditions prevent lost updates. RFC 9457 problem details give failures a stable machine-readable shape. These details let clients correct input, retry work, resolve conflicts, or escalate without interpreting a mystery response.
Then comes compatibility, the part that hides in the shrubbery. Removing a field is not the only breaking change. A changed default, tighter validation, vanished enum value, new authorization requirement, or different timing can upset consumers that never knew an implementation changed. Publish the contract with OpenAPI or AsyncAPI, validate schemas and examples, and give deprecation a migration path instead of a ceremonial warning label.
For the fuller map, use the intro for the resource and lifecycle model, the slides for the design choices, and the cheatsheet for review anchors. The practice reference turns those anchors into a review sequence. The exercise asks you to trace a managed database request through retries, concurrency, errors, and final state. That is where a contract stops being a tidy document and becomes a platform capability.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://spec.openapis.org/oas/latest.html
Supports
- Machine-readable HTTP API descriptions, operations, schemas, security, and documentation
- Contract structure and enum/schema behavior
- https://www.rfc-editor.org/rfc/rfc9110.html
Supports
- HTTP methods, safety, idempotency, status codes, representations, and conditional requests
- 202 Accepted and request precondition semantics
- https://www.rfc-editor.org/rfc/rfc9457.html
Supports
- Problem-details format, media types, members, extension behavior, and security considerations
- https://www.asyncapi.com/docs/reference/specification/latest
Supports
- Machine-readable description of message-driven APIs, channels, operations, messages, and bindings
- https://tag-app-delivery.cncf.io/whitepapers/platforms/
Supports
- Platform capabilities, interfaces, providers, security, and internal customer framing
- Declarative resource and platform lifecycle context
- https://roy.gbiv.com/pubs/dissertation/fielding_dissertation_2up.pdf
Supports
- REST architectural constraints and the 2000 dissertation milestone
- https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md
Supports
- Swagger and OpenAPI release dates from 2011 through OpenAPI 3.1.0
- OpenAPI 3.1 schema alignment and revision history
- https://github.com/asyncapi/spec/releases/tag/v2.0.0
Supports
- AsyncAPI 2.0.0 release milestone for asynchronous API contracts
- https://github.com/asyncapi/spec/releases/tag/v3.0.0
Supports
- AsyncAPI 3.0.0 release milestone for asynchronous API contracts
- https://stripe.com/blog/api-versioning
Supports
- Version-pinned API behavior, incremental upgrades, and the maintenance cost of retained compatibility
- https://konghq.com/products/kong-gateway
Supports
- Gateway enforcement capabilities relevant to platform API traffic policy
- https://cloud.google.com/apigee
Supports
- API management capabilities for publishing and governing HTTP contracts
- https://learn.microsoft.com/en-us/azure/api-management/api-management-key-concepts
Supports
- API products, policy scopes, gateway behavior, and consumer publication
- https://aws.amazon.com/api-gateway/
Supports
- Managed gateway capabilities for HTTP and event-oriented interfaces
- https://tyk.io/api-management/
Supports
- Gateway, portal, and policy controls around published API contracts
