gRPC.
Calling a function on another machine as if it were local, using a compact, pre-agreed format instead of plain text.
Most web APIs send human-readable text (JSON) over HTTP, which is flexible and easy to poke at by hand. gRPC takes a different tack: it lets one service call a function on another as if it were a normal local call, and sends the data in a compact binary format both sides agreed on in advance.
Think of REST as mailing a clearly-labelled letter anyone can read, and gRPC as two machines speaking a tight private shorthand they both learned from the same rulebook. The shorthand is smaller and faster, but you need the rulebook to make any sense of it.
- Dear server, send users.1
REST mails a plain letter: readable text anyone can open and skim by hand.
- Lots of words to parse.2
Easy to test, but the envelope is bulky and both sides spend time reading it.
- Same rulebook, both ends.3
gRPC has both sides learn one rulebook first — a shared schema of the messages.
- Compact and fast.4
Now they speak a tight binary shorthand: smaller to send, quicker to read.
- Like calling next door.5
And it calls a remote function as if it were local — no envelope to address by hand.
- Need the rulebook to follow.6
The trade: browsers can’t read the shorthand directly, and you can’t eyeball it.
Why it is fast and strict
gRPC uses Protocol Buffers: you write a schema describing the messages and methods once, and tooling generates matching code for both client and server. Messages travel as compact binary rather than verbose text, so they are smaller to send and quicker to parse. Running over HTTP/2 also lets it multiplex many calls on one connection and stream data in both directions.
The shared schema gives a strict contract — both sides know exactly which fields exist and their types, caught at build time rather than at runtime.
Where it fits, and where it does not
That speed and structure make gRPC a strong choice for chatty internal traffic between microservices, where you control both ends and want low latency. The downsides: browsers cannot call it directly without a proxy, and the binary format is harder to debug by eye than JSON.
So a common pattern is REST or GraphQL at the public edge for browsers, and gRPC humming between services behind it.