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.

Updating core dependencies is often postponed for years due to the fear of “breaking everything,” causing the risk to grow exponentially. Andrii will present a workflow for jumping across multiple versions: AI analyzes breaking changes and generates transformation rules, AST-based tools handle the routine work, and technical debt becomes a manageable process.

Low Latency in High-Load Systems: From Redis Pub/Sub to In-Memory Runtime — a Toy That Went Too Far In this talk, we will explore real-world experience in building a low-latency system for cross-exchange operations, where geography is just as important as algorithms. We will discuss why message brokers and classic microservices are not a good fit for HFT (High-Frequency Trading)-like scenarios, how in-memory state combined with regional runtime nodes provides predictable latency, and where the boundary lies between speed and consistency.