Open Source Summit India 2026

In the modern practice of Platform Engineering (PE), performance has traditionally been viewed as an outcome of optimization rather than an architectural principle. This session presents a Performance-by-Design methodology that integrates intelligent scaling, guardrails, feedback-driven control loops within Internal Developer Platforms (IDPs). Instead of reacting to incidents, we design platforms that manage latency, throughput, cost efficiency, and stability by applying policy-driven autoscaling, SLO-aware metrics, and Kubernetes-native mechanisms constantly. The session outlines a reference architecture with observability pipelines, custom metrics, horizontal pod autoscaling, and platform guardrails to ensure a self-regulating cloud-native operating environment. We show how performance constraints can be codified into golden paths; teams will inherit optimized defaults. Attendees will receive a structured framework to convert performance from reactive tuning task to platform capabilities - increasing reliability, decreasing resource consumption and allowing scalable innovation on enterprise cloud-native ecosystems.

Modern Kubernetes platforms generate massive volumes of logs, events, metrics, and reconciliation signals, yet developers still struggle to answer a basic question: why did my deployment fail? At Comcast, operating large-scale internal Kubernetes platforms, failures often span platform abstractions, custom controllers, policies, and cluster runtime behavior—making manual diagnosis slow and unreliable.

This talk explores how AI can act as a diagnostic layer in Kubernetes platforms, focusing on failure explanation rather than detection. It presents architectural patterns for correlating platform intent with Kubernetes signals and translating complex control-plane behavior into clear, human-readable explanations and actionable guidance. Attendees will learn how AI can augment platform engineers, improve developer trust, and significantly reduce time-to-resolution without becoming another opaque system.

A broken deployment is every developer's nightmare. Standard CI/CD pipelines fail on minor typos or missing dependencies, forcing engineers to dig through logs and push manual fixes. What if your infrastructure could safely fix itself?
This session explores the transition from rigid automation to AI-driven recovery, introducing the "Pipeline Doctor" in Python: an agentic AI system acting as a self-healing safety net for your repositories.
Allowing AI to write production code sounds terrifying, doesn't it? This is why this talk prioritizes strict execution guardrails. Attendees will learn to set strict tool-calling boundaries around the LLM that securely restrict its capabilities.
Watch me intentionally break a live deployment pipeline to demonstrate how the autonomous agent catches the failure, securely verifies its fix inside an isolated GitHub Actions sandbox, and submits a Pull Request paired with an auto-generated Root Cause Analysis (RCA). Attendees will leave with a practical, open-source blueprint to build self-healing pipelines in their own environments.

Linux kernel development has long since moved past the point of lacking contributors, with around 2,000 developers participating in each release and up to 330 first-time committers [1]. What the development process is missing, however, are reviewers and maintainers.

If you ever thought that becoming a Linux kernel maintainer was something reserved for members of a secret kernel lodge, join this talk in which we will explain why - and how - you should become a Linux kernel maintainer, with a focus on improving the Embedded Linux ecosystem.

Intention of this talk is not only present Krzysztof's ideas how to become Linux kernel maintainer, but also bring discussion with the audience, hoping more senior kernel maintainers will join and participate with their ideas and comments. Thus it could be considered a sort of half-Birds of Feather session.

[1] LWN.net: Some 6.18 development statistics, https://lwn.net/Articles/1046966/

Performance profiling in virtualized environments has traditionally required trade-offs between accuracy and overhead. Mediated PMU, a recent change to Linux's built-in KVM hypervisor, fundamentally changes this by providing guests direct access to hardware Performance Monitoring Units (PMUs).

This talk will:
- Explore the differences between the old and new approaches.
- Demonstrate a reduction in PMU virtualization overhead and improvement in profiling accuracy.
- Discuss the key trade-off: while guests gain direct hardware access, the host loses the ability to profile guest workloads through perf.

This talk is ideal for virtualization engineers, kernel developers, and anyone performing performance analysis in cloud or virtualized environments who needs accurate, low-overhead profiling data.

Virtualizing Performance Monitoring Units (PMUs) requires careful coordination between hardware and software to provide guests with accurate, low-overhead performance monitoring while maintaining security and isolation.

This talk examines what it takes to virtualize PMU features, focusing on a hardware-assisted approach built on the upstream Mediated PMU framework in the Linux kernel.
This talk will
1. Explore motivations such as protecting confidential guests, reducing context-switch overhead, and maintaining host-guest boundaries.
2. Cover hardware support for selective interception, direct interrupt delivery to guests, and automated guest state management, as well as software handling of host state for registers not saved by hardware.
3. Demonstrate performance monitoring counters and instruction-based sampling virtualization, showing how hardware automation improves software-based state management and strengthens security for confidential computing workloads.

This talk is aimed at virtualization engineers, kernel developers, and performance analysts working in cloud or confidential computing environments.