KubeCon + CloudNativeCon India 2025

What if developers could create fully isolated, production-like environments—directly from Backstage—with just a click?

This talk showcases Backstage as a powerful self-service platform to spin up vClusters representing Dev, Test, and Prod environments. Each virtual cluster is fully GitOps-managed with FluxCD, automatically pulling from specific Git branches to mirror real deployment stages.

The environments can be provisioned on-demand—whether on a developer’s local laptop (using WSL), a centralized server, or a remote EKS cluster—offering flexibility and production-like confidence at every stage.

We’ll deep-dive into building this “staging system” where code is tested safely before ever reaching customers, while giving developers the speed and autonomy they crave—all powered by Backstage.

By the end of the session, you’ll learn how to build a practical, cloud-native staging system to test, validate, and promote code safely—before your customers ever see it.

Platform engineering continues to evolve as a critical discipline for modern software development. However, infrastructure complexity is slowing down its momentum. The software infrastructure is a complex web of interrelated entities that spans much beyond a simple software catalog and cloud resources. Such infrastructure management is often driven by a team’s understanding of the implicit relationship between these entities. This is not scalable and often leads to operational challenges and loss of developer productivity. Knowledge graphs can build relationships between entities from diverse infrastructure sources and make explicit what was previously implicit knowledge. It elevates the developer productivity and its neglected counterpart - operational excellence. This talk will discuss the importance of knowledge graphs and the strategies and mental models that will help in building knowledge graphs around the software infrastructure.

Providing application teams with a self-service way of deploying applications and their dependencies often means that platform administrators have to hide the implementation details of the platform via simple to consume APIs. In the case of Kubernetes this usually means having to deploy Custom Resource Definition that are either 3rd party or custom built in-house. These CRD’s in addition to allowing Kubernetes users to manage non-Kubernetes objects via the Kubernetes Resources Model (Aka YAML file), they also allow abstracting away the details of how some resources get created and managed.

In this session, you'll learn how KRO allows platform teams to:
- Create high-level APIs that reduce YAML complexity while maintaining flexibility
- Support both native Kubernetes and cloud-specific resources for more efficient orchestration
- Integrate KRO into your Kubernetes workflows for better scalability and simplicity

As a developer, are you overwhelmed by the growing number of tools just to ship code? Struggling with visibility into cost, performance, and reliability? Torn between enabling developer autonomy and enforcing governance? The answer to all these challenges lies in building an Internal Developer Platform (IDP) like a real product. With clear ownership, iteration, and a focus on your internal users—you solve for both scale and usability. An IDP unifies onboarding, CI/CD, infrastructure provisioning, observability, cost visibility, and more.
You’ll learn how an IDP can streamline the entire developer journey while embedding security and operational best practices by design. We’ll discuss prioritising Developer Experience (DevEx), aligning platform capabilities with developer needs, and avoiding becoming a bottleneck.
Whether you’re a platform engineer or an engineering leader, you’ll walk away with actionable insights to make your platform a true enabler at scale.

Local dev setups worked fine when teams were small. But when you’re dealing with hundreds or thousands of developers, things start to break - slow onboarding, dependency hell, inconsistent environments, and wasted compute cycles.

Cloud Developer Environments (CDEs) promise instant, reproducible workspaces, but shifting from local machines to cloud-first workflows is easier said than done. Latency, security, adoption hurdles, and cost can turn a promising initiative into an operational headache.

This talk will go deep into:

* Why local dev is unsustainable—from wasted CPU cycles to lost engineering hours.
* How cloud environments reduce friction—ephemeral, pre-configured workspaces that just work.
* Optimizing for speed—pre-warmed environments, AI-assisted debugging, and workload-aware compute allocation.
* Measuring impact—tracking developer velocity, infra costs, and sustainability improvements.
* Lessons from real-world rollouts—what works, what breaks, and how to get buy-in.

Infrastructure teams have long been a staple of large enterprises, responsible for creating and managing cloud and on-premises resources. However, each team often operates with its own user interface, making it difficult for developers to access the infrastructure they need efficiently. How can we enhance the developer experience while enabling infrastructure teams to offer products more effectively?

This talk will showcase how Allianz Technology leverages the Kubernetes ecosystem and open-source software to build an infrastructure-as-code platform powered by over 1,000 Kubernetes control planes. This approach simplifies the developer experience through customized APIs while providing infrastructure engineers with a scalable framework for delivering infrastructure products and gaining insights for continuous improvement.

In today's fast-paced development landscape, maintaining reliable and up-to-date test environments is crucial yet challenging. Join us as we share our journey of evolving from traditional long-running test environments to testing directly in production, and eventually achieving scalable and ephemeral test environments for platform builders as well as application teams.

- Are you content with the current state of your test environments?
- Do you find yourself relying on outdated, long-running staging and test environments?
- How do you handle the risks of data staleness and unexpected environment corruption?

In this talk, we will go into the strategies and tools that helped us to transition to ephemeral test environments, highlighting the benefits and challenges encountered along the way. We aim to provide you with practical steps to improve the scalability and reliability of your own testing frameworks.

Imagine walking up to a self-service kiosk at an airport, hospital, or hotel, speaking in your native language, and instantly hearing a real-time translation—without cloud delays or privacy risks. Traditional speech translation relies on heavy cloud compute, but what if it could run directly on low-power edge devices like Raspberry Pi or even phones?
This session demonstrates how Kubernetes (k0s) enables AI-powered multilingual speech translation at the edge, eliminating latency, cloud dependency, and high operational costs. With a single k0s control plane, running outside of edge, managing hundreds of kiosks, AI models are deployed, updated, and scaled seamlessly. We’ll showcase a live demo of real-time speech translation running on edge devices, proving how edge-native AI can revolutionize automated customer interactions.
AI-powered customer service—automated, private, and built for scale.

Running a homelab means running a diverse set of applications like NextCloud, readeck.org, usememos.com.

They are written in many languages and frameworks and in general lack a good way to monitor them. The old way to monitor them involved having a basic blackbox_exporter enabled synthetic monitoring. Even instrumented, each application has a different set of metrics, leading to complex alerting and dashboards.

Grafana Beyla, powered by eBPF and OpenTelemetry, combined with Prometheus promises to generate first class observability signals for services regardless of the language and frameworks used. We will walk through deploying Beyla for a homelab, and the challenges in having good observability even with Beyla.

We will walk through:

1. Deploying Beyla in your environment with Prometheus
2. Setting up dashboards for the data
3. Robust alerting over the signals, especially in low, sporadic traffic (homelab) scenarios.
4. The missing signals from eBPF and how you can fill those gaps

One of the significant challenges faced by Kubernetes-based applications is that performance issues often only manifest in production environments, making them difficult to reproduce in development or staging settings. Imagine if we could "time travel" and recreate real-world production conditions within a controlled environment.

This session explores how a leading global bank (200M customers in 150+ countries) successfully recreated production workloads in controlled settings. By leveraging synthetic data generation, trace playback, and workload simulation, we tackled most performance issues without compromising sensitive data. This approach not only enhanced system reliability and reduced downtime but also improved the bank's ROI by decreasing operational costs by 30% and increasing transaction efficiency by 25%, resulting in significant annual savings.

Join us as we unravel the secrets of "time travel" to replicate production performance and resolve issues effectively.

We built an enterprise-wide observability platform using CNCF Open Source tools (Grafana, Prometheus, Tempo) to address APM needs for Ops, AppDev, CloudFinOps, and Management. This self-service, automated platform offers dashboards, alerts, and notifications.

Challenges:

1️⃣ Flexibility – Observing diverse tech stacks (Java, Node, Python, Go) with standard & custom metrics and tracing.
2️⃣ Scaling – Observing workloads across multiple Kubernetes clusters and regions.
3️⃣ Cost – Fully managed solutions like Dynatrace were expensive.

Solution:

Hub & Spoke Model: Centralized tooling observing global workloads.
✅ Metrics: AWS Managed Prometheus for metrics, self-hosted Grafana for dashboards and alerts.
✅ Traces: Self-hosted Grafana Tempo with S3 storage for cost optimization.
✅ MAC: Fully automated infrastructure with AWS CDK and TypeScript for self-service configuration.

Unlock edge observability at scale. Tackle distributed node chaos with robust monitoring, logging, and security. Dive into architectural patterns for aggregating data across challenging networks. Discover how to build resilient, multi-tenant observability for your edge deployments.
Presentation leverages a real-world case study to illustrate the architectural design patterns and best practices for building scalable edge observability, emphasizing the application of core cloud-native principles and technologies

The Tenant Exporter enhances observability in multi-tenant Kubernetes clusters by delivering curated namespace metrics for GPU workloads at Adobe. Built on Prometheus, it exposes metrics like ingress requests, container CPU/memory, GPU utilization, and quotas. Users can select metrics via a ConfigMap, with quotas managing load.

The architecture features a Prometheus instance for metric collection, an Nginx proxy for load balancing, and secure authentication using prom-label-proxy with kube-rbac-proxy. A live demo will showcase configuring self-service metrics for a GPU namespace, integrated with Prometheus.

Attendees will learn to deploy this system, manage quotas, and scale metric delivery across clusters. Drawing from Adobe's experience with thousands of namespaces, this session offers best practices for observability using CNCF tools to reduce overhead and improve insights. Join us to elevate your Kubernetes observability strategy and optimize GPU workload management.