gRPC

In one line

gRPC is remote procedure calls with a contract: you define services and messages in a .proto file, the toolchain generates typed client/server code, and calls travel as compact binary (Protocol Buffers) over HTTP/2 with built-in streaming.

The problem it solves

JSON-over-REST is wonderful for public APIs but wasteful and loose between your own services: text parsing is slow at volume, and there's no compile-time guarantee the caller and callee agree on the shape. gRPC trades human-readability for speed and a strict contract — the right call for high-volume internal traffic.

How it works

• The .proto contract is the single source of truth. Every language generates stubs from it, so a Python analytics service can call a Go ingestion service with compile-time type safety.
• HTTP/2 gives multiplexing and four call shapes: unary (one request/response), server-streaming, client-streaming, and bidirectional streaming.
• Deadlines, retries, and load-balancing are first-class, not bolt-ons.

The trade-off: binary protocols are not browser-native (grpc-web exists as a bridge) and are harder to debug with curl than JSON.

gRPC vs REST/FHIR — where each belongs

	gRPC	REST / FHIR
Audience	your own internal services	external partners, standards
Wire format	binary (Protobuf)	JSON
Strength	speed, streaming, type safety	universality, debuggability, standards

The rule: the external, standards-facing edge stays FHIR/REST; gRPC is for inside the walls.

Where it shows up in digital health

Internal seams of health platforms: ingestion pipelines, ML inference services, device-gateway → cloud links — anywhere high-volume structured traffic flows between your own services.

Common pitfalls

• Exposing gRPC as your public API — partners expect FHIR/REST; keep gRPC internal.
• Skipping .proto versioning — the contract evolves; manage backward compatibility deliberately.
• Debuggability shock — invest in tooling (grpcurl, reflection) since curl won't do.

Key takeaways

• gRPC = contract-first RPC: .proto → generated typed stubs → binary over HTTP/2.
• Four call shapes including bidirectional streaming; deadlines/retries built in.
• Fast and strict for internal service-to-service traffic; keep FHIR/REST at the edge.
• The efficient plumbing inside a health platform's walls.