The King and Its Kingdom
First, a quick refresher. A REST (Representational State Transfer) API is an architectural style that became the de facto standard for how different software systems talk to each other over the web. Its principles are simple and built directly on the foundation
of the internet: use standard HTTP methods (like GET to retrieve data or POST to create it) and structure data around 'resources' (like '/users' or '/products'). This simplicity was its superpower. It was easy to understand, stateless (meaning each request is independent), and massively scalable, which is why it powered the explosive growth of web and mobile apps. For years, there was little to argue about; REST just worked.
The Pragmatist’s Defense: ‘Good Enough’ is Often Great
One camp of senior engineers argues that REST’s dominance is deserved and ongoing. Their view is pragmatic: REST is the most well-understood, widely supported, and straightforward approach for the vast majority of use cases. Every programming language has robust tools for it, developers are familiar with it, and its performance is perfectly acceptable for countless applications. These engineers argue that the 'disagreement' is often manufactured by hype. Why add the complexity of a new system when the old one handles the job efficiently? For standard applications, especially public-facing APIs where broad compatibility is key, REST is considered boring in the best way possible—it's a reliable, known quantity.
Cracks in the Foundation: Data Demands Change
The disagreement heated up with the rise of complex single-page web applications and data-hungry mobile apps. This is where REST’s primary weaknesses began to show, leading to two common problems: over-fetching and under-fetching. Over-fetching happens when an endpoint returns far more data than the app needs, wasting bandwidth. For example, a mobile app might only need a user's name but receives their entire profile. Under-fetching is the opposite: the app needs to make multiple round-trips to different endpoints to gather all the data required to display a single screen, increasing load times and complexity. This inefficiency, especially on mobile networks, is the core of the technical argument against a REST-only approach.
The Contenders Enter: GraphQL and gRPC
This is where the alternatives come in, championed by a different group of senior engineers. GraphQL, developed by Facebook, was designed to solve the fetching problem directly. It allows the client application to ask for exactly the data it needs—no more, no less—in a single request. This gives front-end developers immense flexibility and power. The other major contender is gRPC, created by Google. It's not focused on data flexibility but on raw performance. Using a more efficient binary data format and the newer HTTP/2 protocol, gRPC excels at high-speed, low-latency communication between internal services (microservices). Engineers focused on hyper-efficient backend systems often favor gRPC for its speed and strict contracts.
It's Not a Battle, It's About the Right Tool
Ultimately, the most seasoned engineers see this less as a disagreement and more as an expansion of the toolbox. The debate isn't about whether REST is 'dead' but about when it's no longer the optimal choice. The so-called disagreement is really a sign of a maturing industry. Choosing an API architecture is no longer a one-size-fits-all decision. The real senior-level move is to analyze the specific problem. Is it a public API for third-party developers? REST is likely the best choice for its simplicity and universality. Is it a complex mobile app with diverse data needs? GraphQL could save significant development time and improve user experience. Is it for thousands of high-frequency messages between internal services? gRPC's performance is hard to beat.
