Course contentsShow
← System Design
Lesson 1917 of 1,91945. API Design and VersioningFree lesson

gRPC: Protocol Buffers and Binary RPC

Understanding gRPC's efficient binary serialization, HTTP/2 multiplexing, and strongly-typed service contracts.

gRPC: Protocol Buffers and Binary RPC

What you'll learn: How gRPC achieves high-performance, strongly-typed API communication through binary serialization and HTTP/2.

What is gRPC?

gRPC is a modern RPC (Remote Procedure Call) framework that lets you call methods on remote servers as if they were local functions. Unlike REST's text-based JSON over HTTP/1.1, gRPC uses Protocol Buffers (protobuf) for binary serialization and HTTP/2 for transport, delivering significantly better performance.

Protocol Buffers: Compact and Strongly Typed

Protocol Buffers define your service contract in .proto files with explicit types:

service UserService {
  rpc GetUser(UserRequest) returns (UserResponse);
}

message UserRequest {
  int32 user_id = 1;
}

The compiler generates client and server code in your language of choice. Because data is serialized to binary format, payloads are 3-10x smaller than equivalent JSON, and parsing is faster since there's no text processing.

Think of it like: REST sends a letter written in paragraph form, while gRPC sends a pre-formatted form with checkboxes—smaller, faster to fill out, and impossible to misinterpret.

HTTP/2 Multiplexing Advantages

gRPC leverages HTTP/2's multiplexing to send multiple requests simultaneously over a single TCP connection without head-of-line blocking. This eliminates the overhead of opening multiple connections (as REST often requires) and enables bidirectional streaming—both client and server can stream data continuously.

Strongly-Typed Contracts

Your .proto file is a binding contract. If the client expects int32 but sends string, it won't compile. This catches integration errors at build time, not runtime—a major advantage over REST's flexible but error-prone JSON schemas.

When to Use gRPC

Ideal for microservice-to-microservice communication where performance matters, but less suitable for browser clients (limited native support) or public APIs requiring human readability.

Key Takeaway: gRPC combines Protocol Buffers' compact binary serialization, HTTP/2's multiplexing efficiency, and strongly-typed contracts to deliver high-performance, type-safe RPC—making it ideal for internal service communication at scale.