Learn gRPC (a high-performance RPC framework built on HTTP/2 and Protocol Buffers) from the basics to production-grade: pre-requisites & environment setup, history & background, core concepts & main architecture, writing your first gRPC API with Protocol Buffers, generating code & running your first server-client, unary streaming & basic error handling, metadata interceptors & lifecycle callbacks, gRPC configuration & local deployment, state data management & schema evolution, health checking reflection & service discovery, HTTP/2 load balancing & connection management, TLS mTLS & authentication, authorization auditing & security best practices, gRPC performance & optimization, observability tracing & monitoring, resilience retry & fault tolerance, gRPC-Web Envoy & gateway integrations, CI/CD GitOps & production deployment, and the modern ecosystem & latest stable tooling — 19 episodes in total.
Before touching gRPC, you need to master the concepts of RPC, HTTP/2, data serialization with Protocol Buffers, plus basic networking and TLS. In this episode you'll also set up the protoc compiler, language plugins, and verify your first installation.

This episode traces the evolution of gRPC from Google's internal RPC system called Stubby, the 2015 open source release, to the standardization of protobuf as an IDL. You'll also compare gRPC with REST/JSON and understand when gRPC isn't the right choice.

This episode dissects gRPC's architecture from the inside: how protobuf becomes client and server code, the role of HTTP/2 multiplexing and HPACK, the stub and channel components, and the metadata, deadlines, and status codes that govern every RPC.

This episode teaches you to write gRPC contracts: the complete structure of a .proto file, modern protobuf v3 data types like enum, oneof, map, and repeated, and how to declare the four RPC patterns — unary, server streaming, client streaming, and bidirectional.

This episode turns a .proto file into real code: installing plugins, the protoc command for Go, implementing a simple server, implementing a simple client, then local testing with a request-response round trip that runs successfully for the first time.

This episode covers the real implementation of the four RPC patterns: unary, server streaming, client streaming, and bidirectional streaming. You'll also learn error handling with status codes, rich error details, and handling deadlines and cancellation on both sides.

This episode covers metadata as RPC headers, client and server interceptors for both unary and streaming, and lifecycle callbacks for request logging, tracing, and authorization context that can be reused across all your services.

This episode composes environment-aware gRPC configuration: environment variables for port, TLS, service discovery, and retry policy, then runs the gRPC server inside Docker and docker-compose for a clean local deployment.

This episode covers how to evolve protobuf schemas without breaking contracts: message versioning and field numbering techniques, gradual service migration, and integrating gRPC with databases or stateful backends using the repository pattern.

This episode covers the gRPC health checking standard grpc.health.v1.Health, gRPC server reflection for debugging with grpcurl, and modern service discovery: DNS, Consul, Kubernetes, and xDS fundamentals.
