Bhargav Parmar
Platform Engineer | OpenTelemetry OBI Contributor | CNCF Kubestronaut
Ahmedabad, India
Actions
Bhargav Parmar is a DevOps and Platform engineer with over five years of experience building, shipping, and operating production infrastructure across fintech trading platforms, telecom, and developer platforms.
A CNCF Kubestronaut, he holds all five Kubernetes certifications — CKA, CKAD, CKS, KCNA, and KCSA and spends much of his time exploring the layers beneath Kubernetes: Linux internals, eBPF, networking, observability, and the kernel datapath.
Bhargav is an open-source contributor to the OpenTelemetry ecosystem, with contributions to OpenTelemetry eBPF Instrumentation (OBI), where he works on extending and improving zero-code, eBPF-based application observability. His recent work includes protocol instrumentation and contributions around systems such as Aerospike, alongside continued exploration of how eBPF, OpenTelemetry, and kernel-level telemetry can be used to understand production systems without modifying application code.
He regularly participates in cloud-native communities and speaks at CNCF events, where he enjoys turning low-level debugging, networking, observability, and Linux internals into practical engineering sessions that are easier to understand and reproduce.
He writes about Kubernetes, Linux, eBPF, OpenTelemetry, and systems engineering at bhargavparmar.dev.
Badges
Area of Expertise
Topics
OpenTelemetry Collector at Scale: When One Collector Is Not Enough
Most OpenTelemetry deployments start with a very simple architecture:
Applications → OpenTelemetry Collector → Observability Backend
For small workloads, this work well.
But what happens when telemetry volume grows, multiple teams start sending data, tail sampling is introduced, or the backend becomes temporarily unavailable?
At that point, scaling the Collector is no longer just a matter of increasing the replica count.
In this session, we will build an OpenTelemetry Collector pipeline from the simplest possible deployment and progressively push it until the architecture starts to fail.
We will begin with a single Collector receiving traces from instrumented applications and synthetic telemetry generators. As load increases, we will observe the Collector itself using its internal telemetry and identify signs of saturation such as CPU pressure, growing exporter queues, failed exports, and refused telemetry.
We will then horizontally scale the Collector and explore the next challenge: stateful processing.
Using tail sampling as an example, we will demonstrate why simply load balancing spans across multiple Collector replicas can produce incorrect or incomplete sampling decisions when different spans from the same trace arrive at different instances.
From there, we will evolve the architecture into a multi-tier Collector topology using trace-aware routing, dedicated processing Collectors, and scalable gateway patterns.
Finally, we will simulate backend failure and observe how queues, retry behaviour, and pipeline recovery affect telemetry reliability.
This is a live engineering session focused on understanding how OpenTelemetry Collector architectures change as telemetry volume, processing complexity, and reliability requirements grow.
The goal is not to present a single “correct” architecture, but to understand the engineering trade-offs that determine when one Collector is enough — and when it is not.
eBPF at Scale: From Observing One Process to 50 Kubernetes Nodes
eBPF is often introduced through small demos: attach a program, observe a syscall, inspect a packet, and suddenly the Linux kernel feels much less mysterious.
But what happens when that same idea has to operate across a real Kubernetes environment with dozens of nodes, hundreds of workloads, and a continuously growing stream of telemetry?
In this session, we will start from the fundamentals of eBPF and build the mental model from the ground up. We will look at where eBPF programs run, how they attach to kernel and userspace events, how maps and ring buffers move data back to userspace, and how these primitives make zero-code observability possible.
Then we will move from theory to a live engineering demo.
We will start with an uninstrumented application and use OpenTelemetry eBPF Instrumentation (OBI) to automatically generate telemetry without adding an OpenTelemetry SDK to the application.
From there, we will scale the same architecture to a Kubernetes cluster with approximately 50 Linux worker nodes and explore the engineering problems that appear at scale: per-node eBPF agents, Kubernetes metadata discovery, API server pressure, telemetry volume, OpenTelemetry Collector scaling, load balancing, and stateful processing such as tail sampling.
The goal of the session is not just to show that eBPF works, but to understand what changes when eBPF-based observability moves from a laptop demo to a distributed cloud-native system.
Expect Linux internals, Kubernetes, OpenTelemetry, eBPF, live debugging, and a real scaling story.
From Chaos to Clarity: SLO-Driven Observability with LitmusChaos, Cilium & Elastic on Kubernetes
A live demo where we deploy microservices on Kubernetes, observe everything through the Elastic stack, and systematically inject failures using LitmusChaos and Cilium — then watch SLO dashboards burn, anomaly detection fire, and five data streams correlate in real time across a single Kibana view. No slides, just chaos, observability, and recovery.
Cloud Native Rajkot 2026
Serverless workloads on Kubernetes using Knative
CNCG Ahmedabad May 2026 In-Person Meetup @ The Intellify
Beyond kube-proxy: live-debugging the eBPF datapath with Cilium
Docker Ahmedabad Meetup – January Edition
Build a Golang-based AI agent, run local Ollama models, and explore MCP, LangGraph, and Docker’s latest AI and image hardening features.
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top