The Carbon-Aware Platform: Building Sustainable Paved Paths with Kepler and KEDA

As developer platforms scale, their cloud footprints quickly become massive operational cost-centers and drivers of carbon emissions. True platform maturity requires optimizing for environmental sustainability alongside performance.

This session delivers a technical blueprint for constructing a green platform using open-source tooling. We will demonstrate how to deploy Kepler with eBPF to capture granular, pod-level energy consumption. Moving past mere visibility, we show how to hook these metrics into Prometheus and leverage KEDA alongside the Carbon Aware SDK to drive automated, carbon-intelligent behaviors such as dynamically shifting non-critical workloads to periods of low grid intensity or downscaling idle environments. Attendees will leave with actionable strategies to transform sustainability into an automated architectural default within their platform’s paved paths.

When Canaries Meet Databases: Handling Schema State Changes in Argo Rollouts

Successfully merging database migrations with progressive delivery requires more than just compatible code; it demands deep telemetry and automated feedback loops. Moving past introductory decoupling strategies, this session explores how to feed database health metrics, query latency anomalies, and migration error rates directly into Argo Rollouts AnalysisTemplates. We will demonstrate how to build automated gates that halt or roll back a canary before a bad schema change compromises data integrity. Attendees will gain an actionable blueprint for implementing metric-driven, database-aware progressive delivery pipelines.

Inside the Engine: Tapping into OpenTofu’s Internal Logging and Tracing for Security Auditing

To safely run Infrastructure as Code at scale, security teams cannot treat the execution engine like a black box. Understanding exactly how OpenTofu parses configurations, communicates with provider plugins over internal gRPC channels, and writes to state files requires deep visibility into the engine's runtime internals.

This technical session explores how to leverage OpenTofu’s internal logging systems and execution tracing mechanics to build a proactive security audit trail. We will break down the engine's internal logging levels, analyze how provider schemas expose sensitive data in debug streams, and demonstrate how to capture these internal telemetry signals directly from execution runners. Attendees will walk away with a practical blueprint for parsing OpenTofu's core logs to detect unauthorized provider actions, trace execution paths, and secure the system pipeline without modifying the core engine binary.

The Guardrail Paradox: Why Secure Software Templates Actually Speed Up Your Day 1 Code

When software engineers hear the words "compliance checks" or "security gating," they immediately envision delayed releases and broken deployment pipelines. This beginner-friendly lightning talk completely flips that script. We will look at how treating security as a Day 1 helper rather than a final gate, drastically accelerates developer velocity.

Using Backstage Software Templates, we will demonstrate how to build an invisible developer paved path. We will show how a novice engineer can spin up a pristine, production-ready microservice that natively contains verified cryptographic identity handles and pre-configured policy limits from the very first commit.

Attendees will learn how shifting security constraints directly into their catalog scaffold completely eliminates the late-stage friction of fixing infrastructure bugs right before a deployment deadline.

Mastering Problem Solving in Engineering with Observability

Are you an engineer tasked with developing and tackling issues in modern applications? Discover how a strategic approach to problem-solving can enhance your efficiency. This session draws on insights from New Relic's observability teams and their experiences with distributed systems, providing a structured blueprint for excelling in problem resolution. Learn about the critical tools and methodologies that have proven effective in diagnosing and resolving complex problems in production environments, enabling you to solve challenges more swiftly, effectively, and intelligently.

Future of Observability in Microsoft Ecosystem with Open Telemetry

In today's distributed cloud environments, understanding system behavior has become increasingly complex. While traditional monitoring tools have served us well, the Microsoft ecosystem is [embracing](https://learn.microsoft.com/en-us/azure/azure-monitor/app/opentelemetry-overview#opentelemetry) OpenTelemetry (OTel) as the future of telemetry instrumentation for observability.

The session will showcase real-world implementation patterns, with focus on a basic app to advanced scenarios of OpenTelemetry across Microsoft's diverse service portfolio. We'll explore how Azure's native services like a simple .NET application, Azure function, and how Azure Monitor's OpenTelemetry support brings everything together, enabling powerful analysis and visualization of your telemetry data.

Attendees will discover how to implement OpenTelemetry in .NET applications, configure custom instrumentation, enable Open Telemetry for various Azure services to leverage Azure’s OpenTelemetry support for advanced analytics with Open Standards.

- App Insights with OTel
- Azure Monitor OTel distro
- .NET OTel Libraries
- Azure Function with OTel

Getting Started with Amazon Distro for Open Telemtry (ADOT)

Discover how AWS Distro for OpenTelemetry simplifies observability by providing a unified approach to collecting and correlating metrics and traces from your applications and AWS resources. Learn how auto-instrumentation and deep integration with AWS services can significantly reduce mean time to resolution, empowering you to identify and address performance issues faster.

This session will cover key benefits, practical use cases, and best practices for leveraging AWS Distro for OpenTelemetry in your cloud environment.

Observing your Blazor WASM apps with Open Telemetry and Real User Monitoring

OpenTelemetry is becoming increasingly popular in the cloud-native ecosystem for observability purposes. However, Monitoring Blazor WebAssembly can be quite challenging, especially when it comes to monitoring the backend of your WebAssembly and even confusing with various Open Telemetry SDKs.
In this talk, we will discuss how to instrument a sample application and configure OpenTelemetry for the backend. We will also learn how to integrate New Relic's Real User Monitoring to achieve better monitoring results.

Keeping High Performing Systems, performant: Tap into modern Observability for Symfony

Maintaining high-performing systems in the current digital landscape is crucial for any organization to keep the leads flowing, deals closing, and the conversation going.

The session will cover how to trace errors, track application performance metrics, identify external service dependencies, and proactively resolve issues to ensure optimal system performance using the New Relic Platform. It will also discuss examples and use cases where New Relic can help improve system performance and reliability.

It will also showcase how it can help capture the metrics from your Mautic deployments and measure the performance for Databases, Infrastructure, external dependencies & more

This talk is ideal for developers, system administrators, and anyone interested in improving their system reliability with Symfony application deployments.

Azure Log Analysis: Understanding Your Options and Use Cases

This session will cover the options for exploring logs in Azure, as well as various use cases for analyzing logs, streaming them to different sources, or storing them for archival purposes.

At a high level, the talk will highlight the use cases and available options for Diagnostic Logs, including:

Log Analytics workspace
Streaming logs to other sources
Logs archival to Azure Storage
Connecting logs to integrated solutions

Is OpenTelemetry the future of Observability?

As we build more distributed systems and leverage new technology stacks into our environments, engineers can become overloaded with alerts and noise. In this talk we’ll cover the core concepts of Observability and OpenTelemetry, and look at why these relatively new terms in the world of modern reliability are key to today’s engineering practices and how the industry is adopting and contributing towards the standardised telemetry