gRPC

REST works great for the web. Human-readable JSON, simple HTTP verbs, universal tooling. But behind the scenes, microservices at Google, Netflix, Square, and Spotify need something faster. Much faster.

When Service A calls Service B 100,000 times per second, every byte of overhead matters. JSON parsing is slow. HTTP/1.1 creates a new connection per request (or blocks on the existing one). Text-based headers eat bandwidth. No native streaming support.

Google built gRPC (Google Remote Procedure Call) to solve these problems for their internal services, where millions of microservices communicate billions of times per day. It uses Protocol Buffers (binary serialization, 3-10x smaller than JSON), HTTP/2 (multiplexed connections, bidirectional streaming), and auto-generated client/server code from a service definition file.

The result: gRPC is typically 5-10x faster than REST for service-to-service communication. But it is not meant for browsers (though gRPC-Web exists). It is designed for backend services talking to backend services, where performance trumps human readability.

Cloudflare's internal service mesh handles over 32 million requests per second between edge services. They use gRPC for the speed and the type safety that comes from shared .proto files across their Go and Rust services.

Every gRPC service starts with a .proto file, a language-neutral definition of the service's methods and message types:

syntax = "proto3";

service OrderService {
  // Unary: one request, one response
  rpc GetOrder (GetOrderRequest) returns (Order);

  // Server streaming: one request, stream of responses
  rpc ListOrders (ListOrdersRequest) returns (stream Order);

  // Client streaming: stream of requests, one response
  rpc UploadOrders (stream Order) returns (UploadSummary);

  // Bidirectional streaming: streams in both directions
  rpc OrderChat (stream OrderMessage) returns (stream OrderMessage);
}

message GetOrderRequest {
  string order_id = 1; // Field number, not value
}

message Order {
  string id = 1;
  string customer_id = 2;
  double total = 3;
  OrderStatus status = 4;
  repeated LineItem items = 5;
}

enum OrderStatus {
  PENDING = 0;
  PAID = 1;
  SHIPPED = 2;
}

The protoc compiler generates client and server code in any language. Go, Java, Python, C++, Node.js, Rust, C#. The generated code handles serialization, deserialization, connection management, and error handling. You just implement the business logic.

The four communication patterns: