Schedule

Kick-off Keynote session for gRPConf 2026

Find out about the latest developments and a look ahead for gRPC.

Dive into the world of gRPC, a modern, open-source Remote Procedure Call (RPC) framework that's transforming how distributed systems communicate. This session will provide a comprehensive overview of gRPC, highlighting its core principles, benefits, and practical use cases. We'll explore how gRPC leverages HTTP/2 for efficient, bi-directional streaming and Protocol Buffers for language-agnostic, strongly-typed data serialization. Whether you're building microservices, real-time applications, or polyglot environments, discover why gRPC is a powerful choice for high-performance, low-latency communication.

Find out about the upcoming features in the gRPC roadmap

In containerized environments, service meshes ensure reliable and secure communication. However, traditional sidecar proxies introduce latency hops, resource overhead, and operational burdens. Proxyless Service Mesh (PSM) solves this by embedding application networking directly into gRPC using open-source xDS APIs.
In this talk, we will demystify Proxyless Service Mesh with gRPC:
• Fundamentals & Architecture: How gRPC acts as an xDS client for service discovery, per-RPC load balancing, and end-to-end mTLS without sidecars.
• Sidecar vs. Proxyless: Key trade-offs in latency, resource efficiency, and deployment simplicity.
• New Features & Capabilities: An overview of recent enhancements, best practices, and new developments in the proxyless ecosystem.
• Live Demo: Deploying proxyless gRPC client/server workloads on GKE with gcloud and demonstrating dynamic traffic management.

Modern automotive cockpit platforms run multiple operating systems — QNX for safety-critical functions, Linux for connectivity, and Android for infotainment — all isolated under a hypervisor on a single System-on-Chip. Traditional IPC mechanisms break down at domain boundaries, creating latency spikes, serialization overhead, and brittle coupling between subsystems responsible for diagnostics, power management, and HMI services.

This talk presents a production case study from a Tier-1 automotive supplier building next-generation In-Vehicle Head Units (IHU) for a global OEM. The engineering team evaluated multiple cross-domain communication approaches — SOME/IP, D-Bus bridging, proprietary shared-memory protocols, and gRPC — before selecting gRPC as the primary inter-domain message-passing framework spanning QNX, Linux, and Android partitions.

Inference engineering is the biggest bottleneck in LLM-based AI systems today. Modern AI platform are increasingly relying on gRPC instead of REST, for communication between inference gateways, model servers, retrieval services, and orchestration layers because every millisecond matters.

This session introduces the engineering principles behind low-latency AI inference. It also highlights the tradeoffs between gRPC and REST as the protocol of choice for production LLM systems. Attendees will compare REST and gRPC for inference workloads, understand unary and streaming RPCs for real-time token generation, and learn how deadlines, cancellation, flow control, retries, and backpressure improve reliability under load. The session also explores how modern LLM serving stacks use gRPC to build scalable inference pipelines. Attendees will leave with practical guidance for designing faster, more resilient AI services using patterns they can immediately apply.

Getting a gRPC service running on Kubernetes looks easy on paper, but beginners often hit the same surprises: gRPC needs HTTP/2, so standard Ingress setups can break. Health checks need a different kind of probe than plain HTTP services use. And gRPC connections stay open for a long time, so standard load balancing does not distribute traffic the way you expect.

This talk is a simple, beginner-friendly walkthrough of deploying your first gRPC service on Kubernetes. This will cover packaging the service, setting up health checks correctly, routing traffic using the Gateway API's GRPCRoute, and fixing the load-balancing surprise. Attendees will leave with a working mental model and a concrete checklist for standing up their first gRPC service in a cluster without the usual trial and error.

This talk introduces service extentions added in gRPC:

ExtAuthz and ExtProc. Instead of relying on external proxies for interception, gRPC has added support for side channel callout to external services via xDS.

ExtAuthz: Perform real-time authorization by shipping peer identity and metadata to external services. It enables dynamic "allow/deny" decisions before an RPC is processed.

ExtProc: Provide deep packet interception for headers and gRPC message bodies using a specialized "GRPC" processing mode. It allows for sophisticated payload transformation, message level filtering and header mutations.

This enables "Security as a Service" model by decoupling complex logic from application and centralising it into pluggable , xDS managed services.

This session is a technical roadmap for developers looking to inject custom security , logging and business logic directly into gRPC data plane.

Client-side load balancing is critical for scaling gRPC applications, but choosing the right strategy can be daunting. In this deep dive, gRPC maintainers will provide a comprehensive overview of traffic management in gRPC. We will start with the fundamentals, covering core policies like Pick First, and transition into advanced, xDS-driven policies such as Ring Hash and Autosharding.

The core of this session will unveil the upcoming autosharding_experimental load balancing policy. We will demonstrate how this powerful new feature enables dynamic routing by communicating with an external sharding service. Attendees will learn how gRPC partitions an application-defined keyspace into distinct ranges, dynamically maps client requests, and relies on robust fallback mechanisms to ensure system resilience. Join us to understand these inner workings and master advanced traffic management without sidecar proxies.

In this session, we will dive into the architecture of gRPC Python and Ruby, exploring how they wrap around and seamlessly communicate with a shared C++ Core library. We will break down the underlying mechanics of these wrappers, helping developers better understand the performance, implementation details, and lifecycle of using gRPC in these popular language environments.

Additionally, we will explore the frontend ecosystem by discussing what is new in gRPC Web. We will cover recent feature updates, the current state of the project, and provide insights into how gRPC Web is maintained behind the scenes. Join us to gain a comprehensive understanding of both the backend wrapped-language architecture and the evolving frontend gRPC Web landscape.

The switch from REST to gRPC is always pitched as an upgrade in terms of performance; however, the truth is that moving production services is not that simple. In this talk, we would like to present you with our practical experience of migrating a heavily used microservices architecture to gRPC, talking about the reasons behind the move, the implementation process, lessons learned, and the results achieved. We will go into details of making the decision to migrate, redesigning the API using protocol buffers, managing backward compatibility, and ways to deploy gRPC without breaking the existing client apps.

Industrial robotics platforms increasingly depend on gRPC for efficient communication between edge controllers, AI services, and cloud-native microservices. This session presents a multi-tier cloud architecture that combines operations sites, Local Zones, provider backbones, and cloud regions to deliver deterministic latency and resilient service communication. It discusses workload placement, scalable gRPC service design, BFD-assisted failure recovery, traffic engineering, and graceful degradation that enables robotic systems to continue operating during network disruptions. Attendees will gain practical guidance for designing reliable, low-latency gRPC-based architectures that support large robotic fleets and industrial AI applications while maintaining operational continuity and predictable performance.

Health probes play an integral role in ensuring Kubernetes cluster reliability, but selecting the correct probe type is important for both security and performance. While exec, HTTP, and TCP probes are popular, gRPC probes provide superior efficiency in modern architectures with ephemeral workloads since they minimize overhead, achieving a 6 to 7x latency improvement from ~40ms down to ~6ms compared to Exec probes. This talk highlights a real world example where a large multi-CPU node with multiple pods had to be probed at intervals under 5 seconds. In such a scenario, exec probes became a bottleneck that impacted system responsiveness, making gRPC the ideal solution. This session will deep dive into gRPC probe (introduced in K8s 1.24) configuration in a cluster and examine how monitoring and overall system behavior is impacted by it. Ultimately, this talk explores recent enhancements to health probes, comparing them to gRPC probes up through the upcoming v1.37 release (KEP-4939).

Are you new to gRPC and looking for a hands-on introduction? Join this beginner-friendly codelab where we will build a "Hello World" server and client using three of the most popular languages in the ecosystem: Go, Python, and Java. We will start by covering the basics of Protocol Buffers (protobuf) and how to define a service contract. Then, we will walk step-by-step through generating the client and server code for each language. By the end of this session, you will have a solid understanding of how gRPC facilitates seamless communication. Note: Attendees should bring a laptop with Go, Python, and Java environments installed.

The AI era has shifted backend systems from simple request-response calls to continuous agent orchestration loops and distributed tool execution. To scale reliably, modern AI workloads require:
Streaming agent interaction
Passing Binary Payloads like dense vector embeddings, audio, and image context.
Flow Control & Backpressure
Distributed Deadlines & Retries
Channel-level authZ/authN, mTLS, and proxy-less load balancing (xDS) across distributed clusters.
In this talk, we start with the workload rather than with a list of gRPC features: what does an AI workload actually need from its communication layer, and how well does gRPC meet those needs?
Finally, we will demonstrate how these gRPC features map directly to agentic workloads and present gRPC as a high-performance, native transport for the Model Context Protocol (MCP).

Building a gRPC service is straightforward; operating it safely in production is not. A seemingly harmless .proto change — a renamed field, a shifted field number — can silently break existing clients even after the build succeeds and the deployment ships. Most CI/CD pipelines validate application code but rarely check whether a gRPC contract stays backward compatible.

This session presents a Production Readiness Pipeline for gRPC that shifts API validation left. Using a live User Service demo, the speaker introduces a breaking proto change that slips past a traditional pipeline undetected, then rebuilds it with contract linting, compatibility checks, security validation, SDK verification, and contract testing gating the release, catching the change before production.

The talk focuses on the API layer, not Kubernetes or service mesh, using only open-source tooling that runs locally. Attendees leave with a reusable pipeline, governance patterns, and a deployment-gating checklist.

In this talk, we will take a look at how BlueCross uses Spark Connect's gRPC for decoupled clients that submit Spark jobs via streaming. We'll walk through the architecture we run in production:
Spark Connect as the single entry point for job submission, Nessie for Iceberg catalog and branch-based data ops,
Dremio as the query/analytics engine,
Kafka for event streaming,
Spark Thrift Server for ad-hoc SQL,
Iceberg tables on S3,
and Helm package deployments into Kubernetes.
Java and Kotlin code submit the Spark Connect jobslifting;
Python and pytest for environment and integration tests.

We will also go through how we configured retry policies in the channel service config, what actually happens on a transient S3 or network blip, where gRPC's retries help and the tradeoffs we hit moving from Thrift-based submission to gRPC streaming.

This session provides a comprehensive guide to gRPC observability, focusing on the essential tools and techniques for distributed debugging and monitoring. We will explore the modern ecosystem, highlighting the central role of OpenTelemetry and gRPC's deep integration with it.

The talk covers the latest advancements in OpenTelemetry Traces (including TCP traces in C++) and newly added OpenTelemetry Metrics.

Finally, we will provide a sneak peek into proposed delay metrics and traces and review other critical observability tools in the ecosystem to give attendees a complete picture of gRPC's full observability stack.

Data engineers live in a world of batch jobs, REST APIs, and "eventually consistent" pipelines. When I first had to connect two internal services in real time, my instinct was to reach for another REST call. Instead, I learned gRPC the hard way, mid-project, on a deadline. This talk is a data engineer's first encounter with gRPC. I will walk through what changed when I moved part of an ETL/ELT pipeline off REST onto gRPC. How Protocol Buffers forced me to finally define my schemas properly, why streaming solved a polling problem I did not know I had, and where gRPC's assumptions clashed with how data pipelines are usually built. I will share the mistakes I made, the moment gRPC finally clicked, and what I would tell any data engineer who has never touched it before.

Enterprises already run hundreds of gRPC microservices with well-designed protobuf contracts. Now every team wants AI agents to call them, and the usual answer is hand-writing a brittle wrapper for each RPC. This session shows a better way, through a reference implementation the speaker built: a bridge that uses gRPC server reflection to discover services at runtime and generate agent tool definitions straight from protobuf descriptors. Proto messages become tool input schemas and RPC methods become callable tools, with no per-service glue code.
The talk walks through the mechanics: reflection, descriptor parsing, type mapping, and dynamic invocation. A live demo points the bridge at a running gRPC service and watches an agent invoke it instantly. Attendees leave with a concrete pattern for making their existing gRPC estate agent-ready without rewriting service code, plus an honest account of what worked and what's hard.

gRPC tutorials make distributed systems look simple: define a .proto file, generate code, and call remote functions like local ones. That abstraction works – until production.

This talk explores four production challenges Python developers repeatedly encounter with gRPC. Through short live demonstrations where attendees predict the outcome before running the code, we'll uncover common misconceptions and build practical mental models.

Topics include evolving Protocol Buffer schemas without breaking clients, handling streaming with flow control and backpressure, and building resilient services using deadlines, and interceptors for cross-cutting concerns like authentication and logging.

Attendees will leave with a deeper understanding of how Python's gRPC ecosystem behaves in production and the confidence to design, debug, and evolve reliable gRPC services.

An open discussion on using gRPC Observability

Server-streaming gRPC is the natural fit for LLM token delivery, until the stream drops. Today, a mid-stream failure means retrying from token zero: wasteful, expensive, and broken for users. HTTP solved this with Range headers in 1999. gRPC has no equivalent for streams.

This talk introduces a resumable streaming protocol built on top of standard gRPC. Using a session cursor, a lightweight server-side token journal, and periodic ACKs, dropped streams resume from the last confirmed token, not from scratch. We'll cover why this is a checkpointing problem (not a retry problem), how to size the journal TTL, and where LLM non-determinism makes naive resumption unsafe. Live demo: a gRPC-streamed LLM generation gets killed mid-sentence and resumes seamlessly on reconnect.

Static call graphs are the backbone of vulnerability triage: they answer "this CVE is in my dependency tree but can an attacker actually reach it?" Algorithms like CHA and RTA work well inside a single binary, then hit a gRPC stub call and go blind. To a static analyzer, a client invoking OrderService.Create() and the server handler implementing it are unrelated programs. The call graph dead-ends at the wire and with it, your ability to reason about exploitability across a microservices fleet, where most real attack paths live.
This talk shows how protobuf definitions can act as the missing linker: stitching client stubs to server handlers into a unified cross-service call graph. We'll cover why RPC boundaries break CHA/RTA analysis, the hard parts (streaming, interceptors, reflection-based dispatch), and applying the stitched graph to real triage, filtering fleet-wide vulnerability backlogs down to findings reachable from exposed RPC methods, with data from production-scale analysis.

What happens when a distributed search engine that has spoken REST and JSON for years learns a new language?

OpenSearch is exploring that question with gRPC and Protocol Buffers, bringing a strongly typed, binary communication layer to workloads such as bulk ingestion, search, and vector retrieval. But moving beyond REST is more than adding another endpoint. It raises engineering questions around API design, performance, compatibility, security, tooling, and evolving a new transport without breaking the ecosystem.

In this talk, we’ll look at how OpenSearch is implementing gRPC, from its experimental beginnings to production-ready capabilities. We’ll explore its internals, how gRPC fits alongside REST, and where it can make a difference for high-throughput and latency-sensitive workloads

We’ll put theory to the test by comparing REST and gRPC using OpenSearch workloads, including bulk operations and vector search, while examining trade-offs rather than assuming gRPC is always faster.

Following up on our update last year, gRPC Rust is advancing rapidly as the next-generation replacement for Tonic. Earlier this year, we released a preview featuring a client complete with TLS, authentication tokens, interceptors, request cancellation, and full support for the official Protobuf Rust crate.

In this session, we will deliver an end-to-end demo of both client and server support, previewing upcoming server APIs. You will learn how to implement familiar gRPC workflows natively in Rust, followed by a look at our project roadmap and upcoming milestones.

Financial transaction systems cannot treat a successful RPC response as proof that money moved correctly. Requests may time out after execution, retries may create duplicate operations, services may evolve their protobuf schemas independently, and asynchronous events may produce states that differ from the original request.

This session examines how to design reliable gRPC APIs for high-stakes, distributed transaction workflows. It presents practical patterns for idempotency, retry-safe operations, correlation and causation identifiers, explicit error semantics, deadline propagation, protobuf schema evolution, and reconciliation between synchronous RPC responses and asynchronous system-of-record events.

The talk will also explore common failure modes, including ambiguous timeouts, duplicate requests, backward-incompatible field changes, overloaded status codes, and APIs that expose transport success without communicating business outcome.

AI systems don't fail like traditional microservices. A single request can span long-lived streams, multiple agents, model providers, tool invocations, retries, and cross-region communication. Traditional request-level metrics often fall short when debugging these complex workflows.

In this hands-on codelab, participants will build observability into a distributed AI system powered by gRPC and OpenTelemetry. Starting with an intentionally under-instrumented application, they will progressively add metrics, traces, and telemetry to diagnose latency, retries, unhealthy subchannels, streaming bottlenecks, and locality-aware routing decisions. Along the way, they'll explore the latest gRPC observability capabilities, including Channelz v2, non-per-call OpenTelemetry metrics, and locality-aware telemetry.

Leave with a production-inspired AI application, practical debugging techniques, and reusable observability patterns for operating modern gRPC-based AI systems at scale.

This Birds of a Feather (BoF) session is an open, interactive roundtable for new developers, external contributors, experienced engineers, and maintainers to collaborate on the future of the gRPC ecosystem. Rather than a formal presentation, this session is a dedicated space to discuss the daily realities of working with gRPC, with a focus on lowering onboarding friction, reducing development pain points, and exploring new use cases.

We will focus on four core areas: 1) New Use Cases, including how gRPC is adapting to AI workloads, edge networks, and distributed agent communication; 2) The Contributor Pipeline, focusing on simplifying PR reviews and onboarding; 3) Developer Experience, addressing consistency and feature parity across language implementations (such as Go, Java, Python, Rust, and C++); and 4) Documentation, discussing how to make getting started and receiving community support more efficient for new developers.

gRPC team members will discuss how the gRPC team took a proactive stance on the new world of AI vulnerability identification.

Learn how the gRPC team worked with the author of the newly open-sourced Mantis Skills (a Portable Toolkit for Building Security Review Harnesses) to identify and address vulnerabilities across their codebase, and build up continuous vulnerability scanning across the gRPC languages.

gRPC simplifies service-to-service communication, but debugging failures isn't always straightforward. Unlike traditional HTTP APIs, issues involving deadlines, retries, streaming, metadata, and HTTP/2 can be difficult to trace and often surface as cryptic errors.

In this session, we'll walk through a systematic approach to diagnosing common gRPC failures using practical examples and modern observability techniques. We'll explore gRPC status codes, interceptors, deadlines, metadata propagation, retries, streaming behavior, distributed tracing with OpenTelemetry, and logging strategies that make root-cause analysis significantly easier.

Whether you're building new microservices or maintaining existing distributed systems, you'll leave with practical debugging workflows, best practices, and a mental model for understanding what really happens when a gRPC request fails.

Join gRPC Colleagues for a High Tea Networking Reception