A real-world-inspired architecture talk about embedding an AI agent into the operational workflow of a highload data pipeline. We walk through a cascade failure scenario: corrupted data enters the pipeline, Kafka queues get stuck, storage pressure grows, thousands of Kubernetes pods start failing and rescheduling, etcd degrades, and PostgreSQL becomes a secondary pressure point. Then we show how an agent built with AWS Bedrock AgentCore, LangChain, and MCP/Gateway could detect early signals, isolate corrupted messages, suggest human-approved fixes, protect cluster stability, and turn noisy telemetry into actionable recovery steps.

Just yesterday, AI was seen as a simple “assistant.” Today, it’s already reshaping hiring, salaries, career growth, and the role of the developer itself. Junior positions are disappearing, code generation is becoming cheaper, and companies are increasingly valuing adaptability and AI skills over years of experience. During this panel discussion, we’ll talk without rose-colored glasses: is AI really taking jobs, why senior-level experience no longer guarantees an advantage, who is winning the new AI race — engineers or prompt-native specialists — and whether software engineering itself is turning into a completely different profession. We’ll discuss what skills will actually matter for developers in the next 2–3 years, whether middle engineers will become the new juniors, and whether the Ukrainian IT market is adapting to AI-driven changes faster than the rest of the world.

What tasks should be delegated to AI right now, and what still requires human intervention? Using a streaming product as an example, we’ll discuss how AI copilots can help QA teams streamline technical routines, scale testing, accelerate releases, and free up time for people to focus on product research, UX, and complex user scenarios

Most systems start with push because it feels natural — the server knows when something changes, so it notifies clients immediately. But at scale, push embeds a hidden cost multiplier: connected users × open items × update rate. Every millisecond of freshness is paid for by every connected user, even those who aren't watching. This talk is based on a real-world production case study at DraftKings. We’ll explore how the data delivery model shapes the cost curve, rather than just the latency profile. We walk through: — the original push-based system and how it accumulated complexity over the years — the scaling pain points that made it unsustainable under peak load — the evaluation process that led to short polling as the answer — a zero-downtime migration strategy across four phases The results were counter-intuitive: a pull-based architecture with short polling outperformed push on data freshness at peak load, while achieving significant CPU and infrastructure cost reduction. The talk closes with a practical framework for deciding when push wins, when pull wins, and what question to ask first.

Communication is one of the key skills of a product manager, directly impacting the quality of decisions, team velocity, stakeholder trust, and career growth. It is often taken for granted: we all send messages, hold meetings, explain tasks, provide feedback, and negotiate with people every day. Because of this, many people assume their communication skills are fine. In practice, however, communication is often where the biggest pitfalls lie: unclear expectations, poorly phrased feedback, unnecessary conflicts, vague agreements, decisions lacking buy-in, and the feeling that the team “just doesn’t get it.” For a product manager, this is particularly critical, as their work relies heavily on the ability to explain, listen, coordinate, influence, and help others move in the same direction. In his talk, Ray will break down what strong communication looks like in product management: how to assess your own level more honestly, where mistakes most often occur, how to explain complex things in simple terms, and how to give feedback in a way that truly helps individuals and the team become stronger.

In this presentation, we will explore a practical use case of implementing effective infrastructure autoscaling using HPA, VPA, and Cluster Autoscaler. While working with standard VPA, we encountered several limitations, including a lack of flexibility in configuring calculation intervals and conflicts when running concurrently with HPA. Consequently, we decided to develop our own custom VPA controller. In our new solution, we: - Achieved stable coexistence of VPA and HPA on the same resources. - Implemented a filtering mechanism for transient CPU spikes during the pod startup phase. - Optimized the architecture by consolidating the functionality of three standard components into a single pod. - Leveraged the new In-Place Pod Resize capabilities introduced in Kubernetes 1.33. Key result: Optimized resource consumption and a 20–40% reduction in infrastructure costs.

Recently, Superhuman (formerly Grammarly) launched Superhuman Go, an AI assistant that works alongside you on every platform. To build it, we needed a scalable solution that supports an unlimited number of agents that dynamically shapes the user interface and looks similar across all supported desktop and mobile platforms. Join me to find out how we discovered solutions for this innovative new product.

Topics include: - Which growth challenges will define 2026. - How AI is changing the speed of MVP launches and product experiments — and why speed without strategic focus does not create sustainable growth. - Why CRO and performance marketing alone are no longer enough for scaling. - How to use AI for research, prototyping, product drafts, and faster solution launches.

In high-load systems, infrastructure costs often grow not because of the load itself, but because of inefficient architectural decisions: overprovisioning, excessive use of managed services, unnecessary data movement, incorrect SLA decisions, and the lack of a transparent cost model. At the conference, we will discuss how to approach cost optimization as a full-fledged architectural practice, rather than a one-time resource reduction exercise. We will also cover workload profile analysis, identifying real bottlenecks, building unit economics for infrastructure, traffic optimization, caching, CDN, observability, and controlled service degradation. Separately, we will look at the trade-off between performance, reliability, and cost: where maximum fault tolerance is truly required, where an eventually consistent approach is sufficient, and where managed solutions should be replaced with a simpler self-hosted architecture.

This talk is about taming AI: the journey from a simple Plan Mode in Cursor/Claude to structured specification systems. We'll break down why GitHub Spec Kit turned out to be too heavyweight, how ADR (Architecture Decision Records) helps agents retain context across sessions, and why OpenSpec by Y Combinator (Fission-AI, W26) became sweet spot. The central thesis: code quality on output equals specification quality on input. Together we'll reflect on the transformation of the developer's role — from "coder" to "spec architect."