Microservicesmedium

REST vs gRPC for service-to-service calls: what are the key trade-offs?

Answer

REST (JSON over HTTP) is easy to debug and widely compatible. gRPC uses HTTP/2 + Protobuf, gives strong contracts, good performance, and supports streaming, but is harder to inspect without tooling and is less browser-friendly. Pick based on interoperability, performance needs, and team/tooling maturity.

Advanced answer

Deep dive

Expanding on the short answer — what usually matters in practice:

Context (tags): microservices, grpc, rest, contracts, http2
Scaling: what scales horizontally vs vertically, where bottlenecks appear.
Reliability: retries/circuit breakers/idempotency, observability (logs/metrics/traces).
Evolution: keep changes cheap (boundaries, contracts, tests).
Explain the "why", not just the "what" (intuition + consequences).
Trade-offs: what you gain/lose (time, memory, complexity, risk).
Edge cases: empty inputs, large inputs, invalid inputs, concurrency.

Examples

A tiny example (an explanation template):

// Example: discuss trade-offs for "rest-vs-grpc-for-service-to-service-calls:-what-"
function explain() {
  // Start from the core idea:
  // REST (JSON over HTTP) is easy to debug and widely compatible. gRPC uses HTTP/2 + Protobuf,
}

Common pitfalls

Too generic: no concrete trade-offs or examples.
Mixing average-case and worst-case (e.g., complexity).
Ignoring constraints: memory, concurrency, network/disk costs.

Interview follow-ups

When would you choose an alternative and why?
What production issues show up and how do you diagnose them?
How would you test edge cases?

Related questions

Microservices

Trace context propagation: what is the `traceparent` header and why should services forward it?

#microservices#observability#tracing

Microservices

Kafka ordering: what ordering guarantees do you get and how do you design for ordering?

#microservices#kafka#ordering

Microservices

Why is synchronous fan-out (one request calling many services) risky, and how do you reduce it?

#microservices

Answer

Advanced answer

Deep dive

Expanding on the short answer — what usually matters in practice:

Context (tags): microservices, grpc, rest, contracts, http2
Scaling: what scales horizontally vs vertically, where bottlenecks appear.
Reliability: retries/circuit breakers/idempotency, observability (logs/metrics/traces).
Evolution: keep changes cheap (boundaries, contracts, tests).
Explain the "why", not just the "what" (intuition + consequences).
Trade-offs: what you gain/lose (time, memory, complexity, risk).
Edge cases: empty inputs, large inputs, invalid inputs, concurrency.

Examples

A tiny example (an explanation template):

// Example: discuss trade-offs for "rest-vs-grpc-for-service-to-service-calls:-what-"
function explain() {
  // Start from the core idea:
  // REST (JSON over HTTP) is easy to debug and widely compatible. gRPC uses HTTP/2 + Protobuf,
}

Common pitfalls

Too generic: no concrete trade-offs or examples.
Mixing average-case and worst-case (e.g., complexity).
Ignoring constraints: memory, concurrency, network/disk costs.

Interview follow-ups

When would you choose an alternative and why?
What production issues show up and how do you diagnose them?
How would you test edge cases?