Core jargon for software architecture, delivery, and engineering culture.
A defined set of endpoints and rules that lets one piece of software request data or functionality from another, without needing to know how it's implemented internally.
Existing clients keep working without modification after something behind the scenes has changed.
A change to an API or system's behavior that forces existing consumers to update their own code, or their integration stops working.
The agreed-upon set of inputs, outputs, and behavior that two systems promise to honor when communicating.
Taking raw transferred data — JSON, bytes — and turning it back into a usable object your code can work with.
A query language for APIs where the client specifies exactly what data it needs, and the server returns exactly that — nothing more, nothing less.
An operation that produces the same end result no matter how many times it's performed, so retrying it is always safe.
A function that runs in between an incoming request and the final handler, used to add cross-cutting behavior like logging, auth checks, or parsing.
Breaking a large result set into pages of a fixed size, so callers fetch one chunk at a time instead of the entire collection.
A piece of code that implements a browser API or language feature in environments where it doesn't natively exist yet.
Capping how many requests a client can make to an API in a given time window, to protect the server from overload and abuse.
An architectural style for HTTP APIs where resources are addressed by URLs and manipulated with standard HTTP methods (GET, POST, PUT, DELETE).
A versioning convention where version numbers follow `major.minor.patch` — patch for bug fixes, minor for backward-compatible additions, major for breaking changes.
Converting an object into a flat, transferable format — like JSON or bytes — so it can be sent over a network or saved to disk.
The server remembers information from earlier interactions and uses it to affect how it handles later requests.
The server keeps no memory of past requests — each request carries all the information needed to handle it on its own.
A callback pattern where one service notifies another by sending an HTTP POST to a URL the receiver registered in advance — triggered by an event, not a poll.
A persistent two-way connection between client and server over a single TCP connection — either side can push data to the other at any time without a request.