What Is gRPC? Modern RPC Framework, Plain English

Short answer

gRPC is an open-source RPC (Remote Procedure Call) framework originally built at Google. It uses HTTP/2 for transport and Protocol Buffers for serialization. The result is service-to-service communication that's typically 5-10× faster than REST + JSON, with strict typing, code generation across 11+ languages, and built-in streaming.

How it differs from REST

	REST + JSON	gRPC + Protocol Buffers
Transport	HTTP/1.1 or HTTP/2	HTTP/2 only
Payload format	JSON (text)	Protocol Buffers (binary)
Schema	Optional (OpenAPI)	Required (.proto file)
Code generation	Manual or via tooling	Built-in across 11+ languages
Streaming	SSE / WebSockets	Native (4 modes)
Browser support	Universal	gRPC-Web only (proxy required)
Performance	OK	5-10× faster typically
Human-readable wire format	Yes	No (debug tooling needed)

What a .proto file looks like

syntax = "proto3";

service UserService {
  rpc GetUser(GetUserRequest) returns (User);
  rpc StreamUsers(Empty) returns (stream User);
}

message GetUserRequest {
  string id = 1;
}

message User {
  string id = 1;
  string email = 2;
  int32 age = 3;
  repeated string roles = 4;
}

You feed this to protoc with a language plugin and it generates fully-typed client + server stubs. No hand-written serialization code, no schema drift between client and server.

The 4 streaming modes

• Unary: one request → one response. Like REST.
• Server streaming: one request → stream of responses. Like an event feed.
• Client streaming: stream of requests → one response. Like uploading chunks.
• Bidirectional streaming: two-way streams over one connection. Like chat.

When to use gRPC

• Service-to-service inside your infrastructure — microservices talking to each other
• Mobile clients on lossy networks — HTTP/2 multiplexing is more efficient than HTTP/1.1
• Real-time bidirectional communication — alternative to WebSocket with stronger typing
• Polyglot stacks — code generation keeps Go service ↔ Java service ↔ Python service in sync

When NOT to use gRPC

• Public APIs for browsers — gRPC doesn't run natively in browsers; you need gRPC-Web + a proxy. REST is simpler.
• Third-party integrations — REST is universal; gRPC requires the consumer to install protoc + generate stubs
• Caching with HTTP/CDN — REST GET responses cache cleanly; gRPC is POST-only at HTTP layer, harder to cache
• Debugging by humans — JSON is readable; binary Protocol Buffers require tooling

The big-name users

Google (originated it), Netflix, Square, Lyft, Cisco, Cloudflare, Spotify all use gRPC heavily for internal service communication. None of them use it as their primary public API — those stay REST.

Related tools

For REST API debugging: JSON formatter + HTTP status codes. Protocol Buffer payloads are sometimes Base64-encoded for transport debugging: Base64 decoder.