Harshita Varma
Associate Product Manager
Bengaluru, India
Actions
Harshita Varma is a contributor to the Kubernetes project, actively involved in the SIG Contributor Experience community, with a focus on enhancing the contributor journey. She began her open-source journey by contributing to the Thanos project, sparking her passion for open source. In March 2022, she was selected as an LFX mentee for Kubernetes under the CNCF. Since then, Harshita has significantly contributed to Kubernetes, earning the prestigious Dan Kohn Scholarship to attend KubeCon EU 2023 in Amsterdam as an attendee. Currently, she continues to engage with the open-source ecosystem, fostering collaboration and inclusivity within the Kubernetes community.
Badges
Area of Expertise
Topics
Architecting the Agentic Data Plane: Scaling MCP
The Model Context Protocol (MCP) solves agent-to-tool integration, but it breaks Kubernetes scaling paradigms. When shifting MCP from local stdio to distributed clusters, platforms hit a wall: standard ingress controllers aggressively terminate long-lived Server-Sent Events (SSE), and stateless proxies fail to maintain the JSON-RPC state machines required by multi-agent loops.
This session engineers the "Agentic Data Plane." We deconstruct MCP’s architecture to expose why traditional L7 routing fails and provide a blueprint for a state-aware infrastructure layer that decouples AI hosts from tool servers.
Attendees will learn:
L7 Protocol Interception: Configuring Envoy to natively inspect MCP JSON-RPC payloads, enabling tool-specific rate-limiting.
Stateful SSE Fan-Out: Tuning TCP draining and keep-alives to support hours-long agent reasoning streams across ephemeral nodes without dropping context.
Transport Decoupling: Shifting from rigid stdio sidecars to scalable HTTP meshes.
Choreographing the Chaos: Multi-Server Orchestration and Semantic Routing Patterns for Enterprise AI
Building a single MCP server to connect a database is easy; orchestrating twenty distinct MCP servers across legacy systems, cloud APIs, and local filesystems without overwhelming the LLM's context window is where production systems fail.
This session bypasses the "Hello World" tutorials to explore production-grade design patterns for multi-server MCP architectures. We will look at how to implement an intelligent "Gateway" layer for dynamic tool discovery, resolve conflicts when multiple MCP servers offer similar tool definitions, and manage fallback orchestration when a specialized server drops offline. Using concrete, open-source architectural patterns, we will demonstrate how to build robust, highly composable agent networks where servers can safely be added or removed without rewriting the agent's core prompt logic.
Doing More With Less: Automating Developer Onboarding with Backstage and Open Source Plugins
Developer onboarding can be slow and resource-intensive, especially in fast-growing teams. In this lightning talk, I’ll share how we used Backstage and key open source plugins to automate onboarding, reducing setup time from days to minutes. I’ll walk through our approach to customizing Backstage, integrating it with existing tools, and streamlining the developer workflow—without increasing operational overhead. Attendees will leave with actionable ideas for using Backstage to optimize onboarding and improve developer experience, even with limited resources.
Hunting Shadows: Detecting "Git-Native" Botnets with OpenSearch Anomaly Detection
Traditional firewalls are useless against modern containerized botnets. Why? Because today's malware doesn't talk to a suspicious IP; it talks to github.com. I classify these as "Git-Native" botnets, and they blend perfectly into your developer traffic. To catch them, we don't need signature matching; we need behavioral mathematics.
This session demonstrates how to turn OpenSearch into a next-generation SIEM for Kubernetes. We will ignore standard logs and focus on ingesting high-fidelity "Meta-Signals" to visualize the specific signatures of a compromised cluster.
Attendees will learn how to build OpenSearch Dashboards that flag:
"Repo Jitter": Using OpenSearch Aggregations to detect the mathematically precise "heartbeat" of a bot polling a Git repository, which looks distinct from human traffic.
User-Agent Anomalies: Correlating API Server logs to spot "Imposter" Git clients running inside pods that should not be pulling code.
The Kill Chain: Visualizing the correlation between a "Git Pull" event and a sudden spike in CPU usage (crypto-mining) to prove the infection timeline.
Orchestrating OpenSearch Clusters on Kubernetes without Data Loss
"GitOps" and "Databases" have historically been enemies. While stateless microservices are easy to manage with ArgoCD or Flux, upgrading a multi-node OpenSearch cluster via Git commits often strikes fear into the heart of Platform Engineers. Will the PVCs reattach? Will the shards rebalance correctly? Or will we suffer a split-brain scenario?
This session bridges the gap between the OpenSearch Operator and GitOps principles. We will move beyond the basic Helm install and architect a robust, self-healing OpenSearch stack running on Kubernetes.
We will cover:
The Operator Pattern: Why using the OpenSearch K8s Operator is non-negotiable for Day-2 operations (upgrades, scaling, and certificate rotation).
GitOps Workflows: How to structure your ArgoCD/Flux manifests to manage index policies and user roles as code, ensuring your search infrastructure is as reproducible as your application code.
Disaster Recovery: A live look at how to handle "StatefulSet" roadblocks when a node goes down, and how to perform automated snapshots to S3 using the Snapshot Management policy.
Zero-Loss Event Harvesting on Resource-Constrained Edge Gateways
Collecting high-throughput telemetry and sensor events at the Kubernetes edge breaks when hitting real-world constraints: volatile WAN backhauls, intermittent network partitions, and strict hardware limits on remote gateways. Running heavy Java or Go-based logging agents on resource-constrained x86/ARM edge nodes eats up the exact memory needed for core workloads. When the uplink drops, unbuffered events are lost, while unchecked local disk buffering risks media wear and node panic.
This session delivers a pragmatic, production-ready architecture for edge data collection that survives network drops without exhausting local hardware limits. We break away from typical cloud-centric logging setups to build a rugged, asynchronous event pipeline tailored explicitly for disconnected edge nodes.
Attendees will learn:
Lightweight Kernel Hooks
Bounded Local Spillover
Backpressure-Aware Backhaul
The "Open" SOC: Architecting a Free Security Lab for 10,000 Students
The biggest barrier to entering the cybersecurity field isn't talent; it's the cost of tools. Proprietary SIEMs (Security Information and Event Management) are expensive, leaving students with "theory" but no "practice." As a community leader who has mentored over 10,000 aspiring engineers, I realized we needed a better way.
This session explores how we used OpenSearch to build a scalable, open-source Security Operations Center (SOC) for education. We will step through the architecture of a "Training Lab" where students can ingest real attack logs, visualize threats, and practice threat hunting—all without a corporate budget.
We will discuss:
The "Free Tier" Architecture: How to deploy a multi-tenant OpenSearch cluster on Kubernetes that scales to thousands of student workloads cost-effectively.
Gamification: Using OpenSearch Dashboards to build "Capture The Flag" (CTF) scoreboards that track student progress in real-time.
The Talent Pipeline: How this open-source approach creates a generation of engineers who are "OpenSearch Native" from day one.
Safe Checkpoint Provenance using Sigstore + Safetensors
Would you run a random shell script from the internet just because it has thousands of GitHub stars? Probably not. So why do we treat AI model checkpoints any differently?" Somewhere along the way, downloading a multi-gigabyte model and immediately loading it into production became an accepted workflow—and that's a software supply chain story waiting to happen.
As the PyTorch ecosystem increasingly relies on pretrained checkpoints distributed through public model hubs and internal artifact registries, establishing trust in model provenance has become just as important as achieving high inference throughput. While Safetensors eliminates the risks associated with arbitrary code execution during model loading, it does not answer equally important questions: Who produced this checkpoint? Has it been modified? Can its origin be independently verified?
How Your Code Becomes a Kernel
We all use torch.compile, but for many of us, it’s a "black box" that magically makes code go fast. This poster is designed to turn that magic into a mental map. I’ve distilled the complex journey of a PyTorch tensor—from the Python frontend through TorchDynamo, into the AOTAutograd, and finally being lowered into a Triton kernel.
Instead of dense code blocks, I’m using visual flowcharts to show where the "graph breaks" happen and how to avoid them. If you’ve ever wondered why your model isn't as fast as the benchmarks promised, this poster will give you the diagnostic tools to look under the hood and fix it yourself. This isn't just a talk; it's a "cheat sheet" for the modern PyTorch developer.
Hunting Shadows: Detecting "Git-Native" Botnets with OpenSearch Anomaly Detection
Traditional firewalls are useless against modern botnets. Why? Because today's malware doesn't talk to a suspicious IP; it talks to github.com. I classify these as "Git-Native" botnets, and they blend perfectly into your developer traffic. To catch them, we don't need signature matching; we need behavioral mathematics.
This session demonstrates how to turn OpenSearch into a next-generation SIEM for Kubernetes. We will ignore standard logs and focus on high-fidelity "Meta-Signals."
We will build a live detection pipeline that flags:
"Repo Jitter": Using OpenSearch Aggregations to detect the mathematically precise "heartbeat" of a bot polling a Git repository (e.g., exactly every 600s), which looks distinct from human jitter.
User-Agent Anomalies: Correlating API Server logs to spot "Imposter" Git clients (like go-git or libgit2) running inside pods that should not be pulling code.
The Kill Chain: How to visualize the correlation between a "Git Pull" event and a sudden spike in CPU usage (mining), using OpenSearch Dashboards to prove the infection timeline.
Hunting Shadows: Detecting Kubernetes Botnet Behaviors with OpenSearch
Containerized botnets are ephemeral; they vanish before traditional forensics can catch them. To detect modern threats like "Crypto-jacking DaemonSets" or "Git-Native C2 channels," we need to move beyond static analysis and embrace real-time behavioral observability.
In this session, we will demonstrate how to use OpenSearch as a high-speed SIEM for Kubernetes. We will construct a threat-hunting pipeline that ingests Kubernetes Audit Logs and Cilium Network Flows to visualize the specific signatures of a compromised cluster.
Attendees will learn how to build OpenSearch Dashboards that flag:
Anomalous User Agents: detecting "imposter" Git clients and non-standard API calls.
Repo Jitter: visualizing the mathematical beaconing patterns of C2 traffic.
Privileged Pod Creation: alerting on unexpected DaemonSet deployments in the kube-system namespace.
Case Studies of Existing use of Linux in Safety-critical Domains
The automotive transition to Software-Defined Vehicles (SDVs) relies on mixed-criticality architectures, consolidating open-source infotainment (Automotive Grade Linux) alongside safety-critical Real-Time Operating Systems (RTOS). This virtualization boundary—often KVM/Xen—is assumed to be a secure airgap. However, guest-to-host communication requires hardware abstraction, primarily via the VirtIO standard.
This 40-minute session conducts a hardcore technical teardown of the virtqueue shared-memory mechanism, exposing how legacy C-based VirtIO backends (vhost-net) introduce critical vulnerabilities into the automotive supply chain.
We will dissect a hypervisor escape utilizing custom fuzzing. By crafting malformed descriptor chains to bypass frontend validation, a compromised guest can force the host's backend into out-of-bounds memory corruption, effectively bridging the airgap into the control plane.
Finally, we will architect the open-source defense: migrating to memory-safe rust-vmm virtualization components to mathematically eliminate buffer overflows, and deploying zero-overhead eBPF probes for kernel-level I/O anomaly detection.
Orchestrating Privacy: A Cloud-Native Approach to Federated Learning
Federated Learning promises privacy-preserving AI, but it introduces massive operational complexity. How do you train models across distributed, heterogeneous environments (edge, multi-cloud) without a central orchestration layer? This technical deep dive explores using cloud-native tools to build a robust federated learning platform. We will architect a solution using Kubernetes-native patterns to manage distributed training jobs, handle data locality, and securely aggregate model updates. This session will cover architectural patterns for orchestrating federated tasks, managing state, and ensuring the reliability of a system designed for privacy and decentralization. This is for engineers and architects building the next generation of privacy-first ML infrastructure.
Anatomy of a Container Breach: A Live Hacking and Defense Demo
How secure are your running containers? In this session, we will find out by putting them to the test. This talk is a live, two-part demonstration of a real-world container breach.
Part 1: The Attack. I will exploit a common misconfiguration in a Kubernetes-deployed application to gain initial access, escalate privileges, and attempt to break out of the container.
Part 2: The Defense. I will then show how a modern runtime security tool like the open-source project Falco can detect this malicious activity in real-time, generate alerts, and give you the visibility you need to stop an attacker in their tracks.
Untangle the Legacy: Modernizing Monoliths with Cloud-Native Strategies
most of us aren't building greenfield applications from scratch. We're living with monoliths, navigating spaghetti code, and battling the accumulated weight of technical debt. Modernizing these legacy systems to leverage the agility and scalability of cloud-native architectures can feel like an impossible task – a journey fraught with risk and complexity.
This session is for every developer, architect, and team lead grappling with the challenge of evolving existing systems. We'll cut through the hype and provide a pragmatic, technical roadmap for strategically untangling monoliths and gradually migrating to a more flexible, cloud-native future. We'll focus on techniques that allow for incremental change, minimizing risk while maximizing the impact of your modernization efforts.
You'll discover how to identify the right seams in your legacy codebase, extract services effectively, and integrate them into a modern cloud-native ecosystem without a complete rewrite. This isn't just theory; we'll discuss real-world patterns and pitfalls, empowering you to start your own modernization journey with confidence.
Key Takeaways for Attendees:
Strategic Monolith Decomposition: Learn techniques like the "Strangler Fig Pattern" and "Bounded Contexts" to incrementally extract services from a monolithic application.
Identify Effective Seams: Understand how to analyze a legacy codebase to find natural boundaries for microservices, minimizing coupling and maximizing refactoring safety.
Data Migration & Consistency: Explore strategies for handling shared databases and ensuring data consistency during a phased migration from monolithic to distributed data models.
Hybrid Deployment & Communication: Discover patterns for smoothly integrating new cloud-native services with existing legacy components (e.g., API Gateways, event-driven architectures).
Minimizing Risk & Maximizing Value: Learn how to prioritize modernization efforts to deliver tangible business value quickly while managing technical debt and maintaining system stability.
Join us to turn the daunting task of legacy modernization into an achievable and rewarding journey. You'll leave with actionable strategies to transform your existing applications into agile, cloud-native powerhouses.
Securing Multi-Cloud Kubernetes with Cilium, Hubble, and Tetragon: A Real-World Case Study
n this lightning talk, I will share a concise case study from a mid-sized fintech company that leveraged Cilium, Hubble, and Tetragon to secure and observe their multi-cloud Kubernetes environment. The session will showcase how we implemented network policies, enabled transparent encryption, and utilized runtime enforcement to meet strict compliance requirements—without sacrificing developer agility. Attendees will see practical examples of troubleshooting, policy tuning, and real-time visibility, highlighting the integration of these CNCF projects to overcome real operational challenges.
From Noise to Clarity: Humanizing Observability in Cloud-Native Systems
As cloud-native environments scale in complexity, observability is no longer just about collecting logs, metrics, and traces—it’s about making sense of them. While modern observability stacks deliver a wealth of data, the real challenge is translating this information into actionable insights that everyone on the team can understand and use, from SREs and developers to business stakeholders.
This talk explores the next evolution: From Noise to Clarity. We’ll dive into practical strategies and open source tools (like OpenTelemetry, Prometheus, and emerging AI/LLM-powered solutions) that help demystify observability data. Attendees will learn how to:
Correlate signals across distributed systems for a unified view
Use AI and LLMs to generate human-friendly explanations of complex incidents
Build dashboards and alerts that surface root causes, not just symptoms
Empower teams to act quickly and confidently—regardless of their observability expertise
We’ll showcase real-world examples.
From Black Box to Crystal Clear: Real-World Troubleshooting with Cilium, Hubble, and Tetragon
Modern Kubernetes clusters can feel like black boxes when network or security issues arise. In this session, we share a real-world case study of how our team used Cilium, Hubble, and Tetragon to diagnose and resolve complex networking and security incidents in a multi-cloud environment. We’ll walk through the challenges we faced, demonstrate live observability with Hubble, and show how Tetragon’s runtime enforcement helped us catch and mitigate threats in real time. Attendees will leave with practical workflows and lessons learned to improve their own cluster visibility, security, and incident response.
Beyond the Basics: Authoring Custom Operators in PyTorch for Performance Gains
Unlock the full potential of PyTorch by building high-performance custom operators in C++ and CUDA. This session provides a deep dive into defining, implementing, and registering custom ops using the latest PyTorch APIs, including TORCH_LIBRARY for operator definition and backend-specific kernels. Attendees will learn how to write device-specific code, manage memory efficiently, and implement both forward and backward passes for autograd support. The talk covers hybrid Python/C++ registration, dynamic loading of compiled extensions, and integration with TorchScript and ExecuTorch for deployment on diverse hardware. Real-world examples will demonstrate how to profile bottlenecks, leverage operator schema management, and replace standard modules (e.g., nn.Linear) with optimized custom variants. By the end, you’ll be equipped to extend PyTorch for specialized workloads, accelerate inference, and contribute robust extensions to the open source community
Invisible Shields: Runtime Security and Virtual Patching in Kubernetes
Traditional patch management is insufficient for mitigating rapidly evolving threats in dynamic Kubernetes environments, where zero-day vulnerabilities can be exploited before official patches are available. This session presents a technical exploration of virtual patching—deploying runtime security controls at the kernel level to intercept and neutralize exploits without modifying application code or requiring downtime. Leveraging open source solutions such as KubeArmor, which utilizes eBPF and Linux Security Modules (LSM) for inline mitigation, and Kyverno for declarative policy enforcement, this talk demonstrates the orchestration of layered security policies that provide defense-in-depth against advanced threats. Attendees will see how to implement granular process, file, and network access controls, automate vulnerability detection and response workflows, and integrate virtual patching into CI/CD pipelines for continuous protection. Real-world use cases will illustrate how these controls block exploitation vectors in real time, ensuring workload integrity while maintaining operational agility
Anatomy of a Git-Native Botnet: Attack Vectors and Declarative Defense
What happens when an attacker weaponizes GitOps against you? This technical deep dive dissects the architecture of a "Git-Native" botnet that exploits CI/CD pipelines and declarative configurations to maintain cluster persistence. We will track the attack lifecycle from a compromised container to unauthorized repository commits that automatically deploy rogue workloads. Finally, we will transition to defense, demonstrating how to neutralize these threats using strict runtime security and policy enforcement to ensure a truly secure GitOps supply chain.
Open Source Summit Korea 2026 Sessionize Event
Data Makers Fest 2026 Sessionize Event
OpenSearchCon Europe 2026 Sessionize Event
PyTorch Conference Europe 2026 Sessionize Event
OpenSearchCon China 2026 Sessionize Event
Container Days London Sessionize Event
DDD Brisbane 2025 Sessionize Event
KubeCon + CloudNativeCon North America 2025 Sessionize Event
OpenSSF Community Day Europe 2025 Sessionize Event
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