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.

Modern platform teams are overwhelmed by reactive operations where manual escalation, delayed remediation, and siloed automation take over. This session presents Event-Driven Platform Engineering as a framework for the design of platforms from ticket-driven systems to autonomous control loops. With the aid of Kubernetes controllers, event streams, policy engines, and real-time telemetry, platforms can identify, decide, and act without recourse to human intervention. We will also look at how events from observability systems, CI/CD pipelines, policy violations, and runtime signals can be transformed into actionable triggers for automation that powers scaling, remediation, governance enforcement, and developer workflows. The talk presents a reference architecture consisting of Kubernetes operators, Prometheus metrics, event brokers, and policy-as-code frameworks for developing self-adaptive internal developer platforms. Attendees will gain a structured approach to designing event-native platforms such as MTTR reduction, SLA compliance, continuous guardrails enforcement, and developer experience enhancement that align with open-source cloud-native environments.

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.