File handling is where many otherwise well-designed APIs cut corners. The result is integrations that work fine for small files and break under production conditions: uploads timing out on slow connections, downloads failing midway through large transfers, clients with no way to resume an interrupted operation. File upload and download have well-established patterns that handle these conditions correctly. Most of them require explicit design choices rather than the defaults.

Simple Upload: When It Is Sufficient

For files under a few megabytes that users upload infrequently, a direct multipart form upload to your API is the simplest approach. The client sends a multipart/form-data POST request with the file as one part and any metadata as additional parts or as a separate JSON field:

GraphQL shifts the design work from endpoint definition to schema design. The schema is the API — every type, field, query, and mutation is declared in the schema, and the schema governs everything the API can do. Designing a GraphQL schema well requires understanding how types compose, how to express mutations that reflect real domain operations, and where GraphQL’s conventions differ meaningfully from REST patterns that GraphQL developers often import by habit.

Caching is one of the highest-leverage performance improvements available to an API, and one of the least consistently implemented. A response that is cached at the right layer — in a CDN, a reverse proxy, or the client itself — eliminates a server round trip entirely. At scale, that elimination compounds: fewer database queries, lower infrastructure cost, faster responses for every consumer. The HTTP specification provides a complete, standardized caching system. Most APIs use it only partially, leaving significant headroom unrealized.

Networks fail. Connections drop. Load balancers time out. Servers restart mid-request. In a distributed system, any request that travels over a network can be sent but not confirmed, leaving the caller uncertain whether the operation completed. This is not a rare edge case — it is a routine condition that well-designed APIs must handle. Idempotency is the mechanism that makes retrying safe when certainty is unavailable.

What Idempotency Means

An operation is idempotent if performing it multiple times produces the same result as performing it once. The outcome is identical whether you call it one time or ten times; subsequent calls do not change anything that the first call already changed.

An API’s data contract — what it accepts as input, what it returns as output — exists whether you define it formally or not. Leaving it informal means the contract lives only in documentation prose and developer intuition, is inconsistently enforced, and drifts between what the documentation says and what the code actually handles. JSON Schema provides a standard, machine-readable format for expressing data contracts that can drive validation, documentation, and testing from a single source of truth.

Most SaaS APIs are multi-tenant: the same infrastructure serves many customers, each operating in isolation from the others. A user of Tenant A should never see, modify, or even know about the data of Tenant B. This isolation is the foundational guarantee of a multi-tenant system, and it must hold at every layer of the stack — not just at the query level, but at the API design level, the authentication level, and the operational level.

Documentation is the first thing a developer encounters and the last thing most teams prioritize. The result is a familiar pattern: the API is built, the launch deadline approaches, documentation gets written in a hurry by someone who did not build the API and does not fully understand it, and integrators spend the next six months filing support tickets that could have been answered by better documentation. OpenAPI exists to break that cycle by making documentation a first-class artifact of the API itself.

Rate limiting is one of those features that looks optional until the moment it becomes mandatory. Without it, a single misbehaving client — a misconfigured retry loop, a runaway script, a bad actor — can degrade or take down your API for every other consumer. With it, you define the boundaries of acceptable usage and enforce them automatically. For any API exposed to more than one consumer, rate limiting is infrastructure, not a feature.

Standard HTTP is a request-response protocol: the client sends a request, the server sends a response, the connection closes or is returned to a pool. This model is efficient for most API use cases. It is the wrong model when the server needs to push data to the client without waiting for a client request — live dashboards, chat applications, collaborative editing, real-time notifications, trading feeds. Three patterns exist to bridge this gap, each with a different complexity profile and a different set of constraints.

REST APIs organize their surface around resources — the nouns of your domain. How you identify, name, and structure those resources determines whether your API feels intuitive or requires constant documentation reference. Good URL design is not aesthetic preference. It is communication: URLs tell developers what the API contains, how it is organized, and how to navigate it. Done well, a developer can infer what endpoints exist from the ones they already know.