RPC

When applications communicate across a network, they need a structured way to exchange messages. While REST models communication around manipulating resources, RPC (Remote Procedure Call) introduces one of the most intuitive models in computing: calling a function that runs on another machine.

What is RPC?

RPC (Remote Procedure Call) is a communication paradigm that allows a program to execute a function on a remote computer as if it were a local function call:

Call a procedure (function) that physically executes on another server.

Instead of constructing HTTP request URLs, query parameters, and headers manually, developers write standard function calls.

// Local function call (executes in the local memory space)
getUser(42)

// Remote Procedure Call (looks identical, but executes across the network)
const user = await getUser(42)

Behind the scenes, the client runtime transforms the function invocation into a network message:

The client transmits the target function name and serialized parameters over the network. The server receives the payload, executes the function, and returns the result.

Simple RPC Example

Imagine a remote microservice that exposes a simple math function:

add(a: number, b: number): number

The client invokes it like any standard asynchronous function:

const result = await add(10, 20)

console.log(result) // 30

Under the hood, the client and server exchange a structured request-response message:

The client developer does not need to know what database, operating system, or internal logic the server uses to produce the result.

What is gRPC?

gRPC is an open-source, high-performance universal RPC framework originally created by Google in 2015. It evolved from Stubby, Google's internal RPC system designed to connect tens of thousands of microservices with ultra-low latency.

Instead of requiring teams to build custom networking logic, gRPC provides a standardized framework that handles:

• Binary Serialization: Compact, high-speed encoding using Protocol Buffers.
• Modern Transport: Multiplexed streaming over HTTP/2.
• Automated Code Generation: Type-safe client stubs and server boilerplate across multiple programming languages.

RPC vs. gRPC

It is important to distinguish the general computing concept from the specific framework:

• RPC is the architectural concept (calling remote functions).
• gRPC is a modern, production-grade implementation of that concept created by Google.

RPC vs. REST

The fundamental difference between REST and RPC lies in the mental model used to design the API:

REST (Resource-Oriented)

APIs are modeled around nouns (resources) manipulated through standard HTTP verbs:

GET    /users/42        # Retrieve user
POST   /users           # Create user
DELETE /users/42        # Delete user

RPC (Operation-Oriented)

APIs are modeled around verbs (procedures / actions):

getUser(42)             // Retrieve user
createUser({ ... })     // Create user
deleteUser(42)          // Delete user

Comparison Table

Under the Hood: The Network Lifecycle

Even though RPC syntax looks identical to a local function call, it is still a network transaction.

When you execute an RPC call, the framework coordinates a multi-step lifecycle:

The RPC framework hides the serialization, transport, and deserialization boilerplate so you can focus on application logic.

Key Takeaways

• RPC (Remote Procedure Call): An architectural paradigm that makes invoking a function on a remote server feel like calling a local function.
• gRPC: A high-performance, open-source RPC framework created by Google, built on HTTP/2 and Protocol Buffers.
• Protocol Buffers: A language-neutral, type-safe IDL and binary serialization format used to define service interfaces and data schemas.
• REST vs. RPC: REST is resource-oriented (nouns), while RPC is operation-oriented (verbs).
• Microservices Powerhouse: gRPC is widely adopted for internal microservices due to its compact binary payloads, HTTP/2 multiplexing, and cross-language code generation.

RPC makes remote communication feel like calling a function, while gRPC provides the modern protocol, serialization, and tooling to make that communication fast, reliable, and scalable.