KubeCon + CloudNativeCon India 2026

The cloud-native ecosystem is creating new opportunities for engineers across the world. The Kubestronaut program, built around advanced Kubernetes certifications, showcases how structured learning and technical excellence can help engineers gain industry recognition, deepen their expertise, and accelerate career growth.

This keynote explores how continuous learning, Kubernetes certifications, open-source participation, and hands-on platform engineering can help engineers build strong technical foundations and meaningful careers in cloud native technologies. From learning Kubernetes concepts to enabling others through mentorship and community engagement, the journey reflects the power of practical learning and consistent upskilling.

The session also highlights how community-driven programs, technical certifications, and real-world experience can help aspiring engineers gain confidence, deepen their expertise, and actively contribute to the growing Kubernetes ecosystem. As cloud-native adoption continues to expand, the next generation of engineers has an opportunity not only to build scalable systems but also to shape the future of the community itself.

Manoj K R, a Kubeastronaut and Senior Software Engineer at Motorola Solutions, CPS, shares how Kubernetes and CNCF technologies such as cert-manager, KEDA, HPA/VPA, Cilium, Kyverno, and multi-tenant platform automation are being used to support 911 and other mission-critical enterprise applications on shared Kubernetes platforms across cloud environments. This keynote preview will highlight how cloud-native platform engineering enables workload isolation, scalable traffic management, DNS automation, security governance, and reliable operations for critical workloads at scale.

We have been coming to KubeCon for ten years and talking about supply chain security for at least five of those years. We know the attacks and the mitigations. We have the frameworks, the SBOM attestations and the CNCF projects.

So why are the houses still burning?

That is what this talk is about. Not the tools, you know the tools. The gap between knowing and doing. And what happens when AI arrives on both sides of that gap at the same time.

Every security vulnerability comes with a score. But no severity score captures what it costs to be the person who reads that advisory at two in the morning, maintaining a project in the hours between their actual job and life, for a community that depends on them.

GitHub RCE, Trivy supply chain attack, tj-actions compromise, the xz backdoor. CVSS rankings from High to Critical. And behind every one, a human.

Every technological wave has done this. Humans absorb the cost.

The CNCF TAG DevEx survey of nearly 100 projects confirms top concerns of maintainers include security vulnerabilities and the burden caused by a potential flood of low-effort PRs and issues.

This talk traces the human cost across real incidents, asks why the pattern keeps repeating, and explores what it would take to finally break it.

Key takeaways include empathy for the maintainers along with a demo of how the same AI could be used to help maintainers know whether a published CVE affects their project and to what extent.

In highly regulated fintech environments like Razorpay, compliance with RBI and PCI DSS mandates is a license to operate. A single misconfiguration can trigger severe penalties or risk payment licenses. However, traditional manual "audit toil" and late-stage production fixes create massive engineering friction and business risk.

This session explores a multi-layered, automated framework to map complex mandates directly into "Policy-as-Code" (PaC) controls. The speakers demonstrate how to move from periodic audit woes to "steady-state ops hygiene" using PaC across three critical layers: Proactive Controls (Shift-Left) to catch issues in CI/CD, Preventive Controls to block non-compliant workloads, and Detective Controls for continuous, automated evidence gathering.

You will learn how to translate abstract compliance standards into enforceable policies and immutable audit trails, reducing technical debt and satisfying regulators without slowing down innovation.

This talk shares slice's platform engineering journey from monolithic systems to 100s of cloud native microservices on K8s. It explores how ownership, GitOps, container security, observability, clone spaces, custom CI runners, and AI agent infrastructure helped build security, compliance, reliability, and speed into the platform.

A practical story of how owning the core, building strong platform capabilities, and making the Secure path the fast path can turn cloud native engineering into a competitive advantage.

SBI is the largest public sector bank in India catering to more than 52 Crore customers ranging from rural to NRI Customers. Given such dynamic geography to address, the Bank needs a robust cloud platform to not only serve high-volume digital transactions for applications like UPI but also provide flexibility to host modern container & AI apps.
This session focuses on how SBI has built a robust Sovereign Cloud Platform Meghdoot to cater the varied application demands

Learn how this Sovereign Cloud stack supporting an enterprise Kubernetes platform provides strict compliance, zero-trust security, and the flexibility needed to support the daily digital transactions of millions of citizens. You can expect practical lessons on managing large enterprise workloads, connecting legacy infrastructure with cloud-native design, and setting a new global standard for sovereign digital banking.

At Shopify, applications don't all live on Kubernetes. They live on Kubernetes, on VMs, and on serverless. Hundreds of services across multiple regions, reached through a single deploy plane. At peak last Black Friday, this fleet served 489 million requests per minute and ran across 3.18 million CPU cores.

None of this would exist without the CNCF ecosystem. A request to Shopify flows through a layered edge — CDN, regional load balancers, and tenant-routing proxies — before reaching a workload on Kubernetes, VMs, or serverless. In this keynote, we walk through how Kubernetes, Envoy with xDS, custom resources and controllers, and an observability stack built on Prometheus, Thanos, and OpenTelemetry compose into a single orchestrator that ships code safely across every runtime in our fleet — with phased traffic shifting, automated rollback against live error metrics, and an audit trail expressed in git.

Attendees will leave with a mental model for using cloud-native primitives to build a deploy control plane that scales beyond Kubernetes. This is the story of what cloud native makes possible when AI is writing the code faster than humans can review it — and the deploys still have to be safe.

This talk tackles the global GPU shortage and a critical cloud-native reality in batch workload scheduling: "Kueue Quota reserved" does not equal "Capacity available". For production inference, this distinction determines whether workloads succeed or remain stuck indefinitely.

The session explores transcending regional silos using MultiKueue to manage a global federation of worker clusters. Moving beyond basic setup, the speakers address the "Quota vs. Datacenter Capacity" dilemma. They reveal a critical gap discovered through experiments: workloads becoming stranded in regions with exhausted capacity despite available quotas.

The speakers share their collaboration with the community to resolve these scheduling gaps (Issue #8089). This talk demonstrates the configuration aspects of Admission Checks and provisioning classes in Multikueue to force the scheduler to "hunt" for actual capacity in worker clusters across regions rather than relying solely on user-provided quota.

AI engineers often choose between laptops that cannot keep up and expensive shared cloud clusters, which slows iteration. This session shows how to turn a single NVIDIA DGX Spark into a personal AI cluster using Kubernetes, GPU tooling, and Dynamic Resource Allocation.
Starting from a minimal single-node cluster, we add GPU enablement, an AI app stack, and DRA-based GPU sharing. You will learn how the NVIDIA GPU Operator and DRA drivers expose GPU capabilities, how ResourceClasses and ResourceClaims work, and how to enable multiple workloads to share a single device with predictable behavior. A live demo runs an interactive chat or multimodal app beside a background job on the same GPU, using different DRA policies and observing enforcement at runtime.
You leave with a clear mental model, reusable YAML, and patterns that remain portable from a desk-side Spark to multi-node cloud clusters, plus basics for utilization visibility, capacity planning, and multi-tenancy.

This session is based on real production experience building and operating an observability-driven CI/CD platform using CNCF projects. It shows how OpenTelemetry can extend beyond application monitoring to become a core primitive for modern CI/CD systems.

While running dozens of Kubernetes clusters and handling 60M+ requests per minute, costly east-west network load balancers and fragmented CI metrics created blind spots that hid deployment failures. Traditional dashboards showed healthy systems, while rollouts quietly broke.

We share how treating Jenkins pipelines as distributed systems enabled end-to-end tracing across builds, deployments, and runtime behavior. By correlating CI signals with OpenTelemetry traces, we detected cascading failures and closed the loop with automated GitOps rollbacks. The talk covers real challenges, trade-offs, and lessons learned to build reliable, self-healing delivery pipelines.

Your platform team is trying to integrate AI workloads, your developers want to deploy agents and your leadership expects 10x efficiency with AI but when you dig into the specifics, the terminology becomes a maze: AI Agents, MCP Servers, and Dynamic Resource Allocation (DRA). Where do you even start?

This session is centered around what problem each of these solve. In this hands-on 101 guide I will start by demystifying how AI agents operate on Kubernetes—how they interact with workloads, the role of MCP servers in enabling multi-agent coordination, and the fundamentals of DRA for intelligent resource management. Then, I will bring it all together with a live demo showing how AI agents can dynamically tune DRA drivers to optimize scheduling and resource usage in real time. Whether you’re an engineer, researcher, or just Kubernetes-curious, this session will equip you with the foundational knowledge and confidence to start experimenting with agentic and adaptive systems on Kubernetes.

As ML workloads move onto Kubernetes, many teams unintentionally turn their clusters into data platforms storing training data, features, and intermediate artifacts alongside compute. While convenient at first, this approach introduces hidden costs that surface over time.

This talk shares real-world lessons from operating ML pipelines on Kubernetes where data management, not models, became the primary source of failures. We’ll explore common anti-patterns involving PVCs, object storage mounts, and ephemeral volumes, and how they led to rising costs, broken reproducibility, and pipelines training on stale or incorrect data. Finally, we’ll discuss practical cloud-native patterns for managing ML data that respect data lifecycles, improve lineage, and keep Kubernetes focused on what it does best.