Partnership with AWS almost always starts with resistance: “it’s bureaucracy,” “we don’t have time,” “it doesn’t add product value.” In this talk, we’ll show how we transformed AWS programs (FTR, Ready, Delivery, Competencies) into a managed operating system for working with a portfolio of projects. We’ll break down how we gained support from both the business and engineering teams, how we aligned on priorities, and how we translated expectations into clear artifacts: evidence packs, templates, KPI formats, business outcomes, and enablement materials. We’ll explain how roles and ownership are structured, what operating rhythms we use, how quality gates and case selection criteria work, and how we respond to Amazon feedback like “be more specific” so that each next submission becomes stronger and faster.

When a partner submission system is already up and running, the main challenge becomes consistently turning findings into production changes and proving their impact with metrics. In this talk, I’ll walk through our practical cycle: finding → fix → impact validation → scaling the pattern across multiple teams. We focused on metrics that turn SRE into a manageable system. We measure the speed, stability, and cost of changes so that decisions are driven by data rather than intuition — with security now embedded as part of this pattern. We’ll break down how to avoid “local” fixes, make changes reproducible, and sustain progress continuously rather than as a one-time effort.

This is a story about real pain and the maturation of a logging system. We’ll examine how the lack of standards breaks observability and why Kubernetes became the point of no return, forcing us to rethink our entire logging approach. We’ll walk through the requirements and architectural decisions that helped us regain control. I’ll share hands-on experience in building controlled, production-grade log pipelines - without magic and without “silver bullet” tools. This is an honest story from real production environments.

This talk demonstrates practical approaches to unified observability, where metrics, logs, traces, and profiles are integrated for rapid diagnostics in distributed systems. We will cover data correlation techniques using trace IDs and labels to enable instant navigation from errors to specific spans, setting up continuous profiling for preview environments, using flame charts for performance analysis, and leveraging dependency maps and service graphs to visualize architecture. Special attention is given to AI-specific aspects: applying AI assistants to automate root cause analysis and implementing AI Evals for systematic evaluation of the quality, correctness, and reliability of AI systems.

Within the Security Hardening initiative, we introduced an Access as Code approach for managing AWS permissions. Each repository is assigned a dedicated IAM role with permissions aligned to the principle of least privilege. Role management is centralized in a single repository, where each service is defined using a single YAML file. All changes go through pull requests and approvals, while Terraform and Atlantis automatically create or update IAM roles. As a result, we achieved scalable, auditable, and secure access management without direct access to AWS for engineering teams.

This session explores the evolution from simple LLM chains to robust cognitive architectures, focusing on deploying stateful agents within your own perimeter (On-Premise). We will compare modern orchestration frameworks, contrasting Google ADK (Agent Development Kit) for structured, model-agnostic agent design against LangGraph for granular state control and CrewAI for multi-agent role-playing. A key focus will be the Model Context Protocol (MCP) — the new standard for connecting agents to internal data and tools without vendor lock-in. We will demonstrate how to build a flexible runtime using Vercel AI SDK Core (deployed in Docker) to serve these agents, ensuring full independence from cloud providers. Finally, we will cover the AgentOps stack, detailing how to implement self-hosted observability (via Langfuse) and access policies to safely manage autonomous systems in production.

This talk is about a real DevOps project whose journey turned out to be strikingly similar to the storyline of The Phoenix Project. I will walk through the entire path: building the platform, migration, working with development teams, communicating with the business, operating the system under load, and the kinds of mistakes that become visible only over time. This is not a retelling of the book and not a success story. It is a conversation about systemic decisions, responsibility, learning, incident preparedness, and how complex technical systems shape the behavior of the people within them. The talk focuses not on tools, but on the insights that appear only when a project is lived from start to finish — from an idea to the reality of production.

Every engineer has their own path in IT. Mine didn’t start with polished presentations or clear plans — it started with me being lifted by a crane to fix a screen at the Metalist Stadium. Then came telecom projects, autotests, Red Hat, OpenStack, OpenShift — and a constant search for where to move next. Over time, the rough scripts I wrote just to save myself a few hours started holding production systems together. “Fires” turned into opportunities for new solutions, and experiments became experience that truly worked. And somewhere along the way, there were moments when I wanted to leave IT. But instead, DevOps01 appeared — then a community, and eventually AWS and HashiCorp ambassadorships. In this talk, I’ll share how the ongoing search for myself in the profession — and for the profession within myself — became the driving force that changed not only my career but also my life. How small initiatives grow into big systems, and how the community opens new doors.

This talk is dedicated to the practical experience of transitioning from the classic Istio architecture with sidecar containers to a new model - Istio Ambient Mesh. We will tell how scaling a microservice infrastructure on Kubernetes led to increased resource costs, complicated CI/CD, and delays in launching services. The search for solutions led us to implement Ambient Mesh, an architecture without sidecar containers that greatly simplifies mesh integration and reduces infrastructure costs. The presentation will detail the technical aspects of the migration: how we prepared for the transition, what challenges we faced during the implementation process, and how we managed to overcome them in cooperation with the Istio community. We will share the results, analytics, real before/after metrics, and give practical advice to teams planning to implement Ambient Mesh in production.