OSS + ELC EU 2026

Running etcd across thousands of production Kubernetes clusters reveals critical failures: data corruption, quorum loss, member failures, and storage bloat, all capable of disrupting clusters. Managing these manually is complex, error-prone, and difficult to scale.

In this talk, we will be sharing lessons from 8+ years of operating production-grade etcd at scale with close to zero manual intervention and how we built etcd-backup-restore to reliably automate tasks like scheduled backups, corruption detection, quorum loss recovery, member replacement, and scheduled defragmentation, with zero recorded data loss across thousands of clusters.

Used in production by SAP Gardener, Akamai Cloud, StackIT, and Scaleway, etcd-backup-restore is now a Linux Foundation project under Linux Foundation EU via the NeoNephos Foundation, with an active maintainer community. We'll show what it takes to run etcd reliably at scale, and make it truly self-healing.

For a decade, the default answer to "where does Kubernetes run" was someone else's cloud. But lately, regulated organizations, telcos, banks, and the public sector are pulling sensitive workloads back onto hardware they own and operate — for cost, performance, sovereignty, and increasingly to run AI and GPU workloads they control. The hard part is doing that without giving up the automation the cloud offers.

This talk covers the open-source stack for running your own bare metal, with each layer explained by the people who work on it. At the bottom, Metal3 turns physical servers into declarative Kubernetes resources and manages their lifecycle through the Kubernetes API. At the top, k0rdent manages fleets of those clusters with templates, policy, and drift detection. In the middle sits Cluster API, the standard both layers build on.

We'll walk through the layers working as one — from a rack of bare metal to provisioned clusters to a managed fleet, on hardware we run ourselves. Attendees get a reference architecture, practical guardrails, and clear criteria for when this fits. We'll be honest about the trade-offs: slower provisioning and elasticity bounded by the servers you have.

Building on my Google Summer of Code experience, this tutorial addresses one of the major challenges in open source software systems – at scale, file management results in overly complicated templates and bad composability. People put logic into YAML files resulting in non-debuggable pipelines while local modifications are wiped away by upstream updates.
This tutorial delves into the idea of Configuration as Data with the help of kpt tooling allowing for logic separation from configuration files. The idea is to keep YAML "dumb" and pure data, which makes it fully predictable and WYSIWYG.
You’ll get to use the example of the OpenTelemetry Demo - a complex e-commerce microservices application – by packing it in independent and dependent subpackages.
Using KRM functions and custom Starlark scripts you'll:
• switch from a shop selling astronomical equipment to a website offering flowers
• localize languages, currencies, taxes
• manage different deployments sizes (small/medium/large).
As the last point you will use three way merging to allow applying upstream package updates while keeping all local changes safe.

Spot instances reduce cloud bills by up to 90%, but choosing which to use is a multi-dimensional puzzle where price, performance, interruption risk, and instance heterogeneity all interact. Kubernetes provisioners like Karpenter optimize a narrow slice of this problem, tightly coupled to a single cloud vendor, AWS.

KubePACS is an open source project that separates the decision from the execution. A vendor-neutral optimizer computes the best mix of instance types for a workload's cost-performance-availability profile, then translates that into native configuration for the user's provisioner

The talk goes deep into the system: the ILP-based selector for cost-performance-availability trade-offs, the GSS-driven optimizer that tunes them automatically, multi-node spot placement awareness for robust capacity across cloud providers, and clean integration with upstream Karpenter.

Attendees see measured gains over baseline configurations and take away an architecture pattern for performance-aware spot instance provisioning. We close with our intent to grow KubePACS as an open source community effort and welcome contributors to shape what comes next.

Most IaC tools, Terraform chief among them, keep a local copy of state to plan changes, detect drift, and resolve references. That state file is also a known source of pain: it can go stale, get corrupted, and become a coordination bottleneck.

What happens when an IaC system deliberately keeps no local state? Instead of a stored snapshot, every operation reconciles desired configuration against live state at apply time. That single choice shapes everything else, and not all of it is smooth sailing.

Drawing on her experience building widely adopted open-source declarative CLIs, Prashansa unpacks the lessons she learned. The talk covers the tradeoffs statelessness forces: full-state sync versus additive configuration and when each fits, resolving references without a stored dependency graph, schema-aware diffing, and transparent reconciliation so users see what a tool does. It also covers production challenges: compatibility across platform versions, evolving schemas, and keeping behaviour predictable as systems grow.
Attendees will leave understanding why most IaC tools rely on state, what gets simpler and harder without it, and how to weigh these tradeoffs in their own systems.