Defines constraints for building scalable, evolvable web services that leverage standard HTTP methods and stateless interactions.

Communicates the principles and constraints of RESTful design when discussing or documenting web APIs and network‑based systems.

When designing, reviewing, or documenting HTTP‑based APIs; discussing microservices, web services, or choosing an architectural style for networked applications.

Software architecture discussions, API design interviews, backend development, microservices architecture, RESTful API documentation, cloud service design.

Client‑server stateless interaction with a uniform interface (standard HTTP methods, URI‑identified resources, and representation exchange).

Client‑server architecture where interactions are stateless, resources are identified by URIs, and manipulations occur via standard HTTP verbs (GET, POST, PUT, DELETE, etc.) exchanging representations (JSON, XML, etc.).

{HTTP method}, {resource URI}, {representation format (e.g., JSON/XML)}

• RESTful API
• RESTful service
• REST endpoint
• REST architecture
• REST design
• HATEOAS

• SOAP
• GraphQL
• RPC
• gRPC

Assuming any HTTP API is RESTful; misusing HTTP verbs (e.g., using POST for all operations); ignoring HATEOAS and hypermedia controls; treating REST as a protocol rather than an architectural style.

SOAP: protocol with strict contracts and XML envelopes vs. REST’s flexible uniform interface; GraphQL: query language for data fetching vs. REST’s resource‑oriented approach; RPC: procedure‑call model vs. REST’s resource‑centric model.

Coming from SOAP: may expect strict XML contracts and WS‑* standards → REST relies on informal contracts and varied media types; Coming from RPC: may tunnel operations via POST → REST encourages using standard HTTP methods (GET, POST, PUT, DELETE) for CRUD operations.

• API styles
• Web services
• Distributed systems
• Microservices

REST is not suitable when low‑latency, binary protocols or complex transactions are needed; its reliance on HTTP can introduce overhead compared to specialized protocols; a true RESTful service must honor hypermedia as the engine of application state (HATEOAS), a constraint often overlooked in practice.

Enables scalable, cacheable, and evolvable web services that can leverage HTTP intermediaries (proxies, caches, CDNs) and evolve independently of clients.

Think of REST as the postal service: letters (requests) are sent to addresses (URLs) using a limited set of standard verbs (GET, POST, etc.), and the post office (proxies, caches) can forward or store them without needing to know the letter’s content.

REST does not prescribe a specific payload format; while JSON is prevalent, XML, HTML, or plain text can also be used as representations.

Consider GraphQL for flexible data queries or gRPC for low‑latency, strongly‑typed RPC when REST’s constraints become limiting.