We will take a look inside React Server Components using an implementation in the Clojure programming language. You will learn what the “magic” of server components looks like under the hood, how component streaming works, and whether it’s really possible to send a Promise over an HTTP request from the server to the client. How can a function that exists only on the backend be invoked on the frontend? How can we make server components run fast? In addition, we will dive into Clojure to see how the same concepts can be built in a radically different programming language.

Have you ever wondered what’s really going on under the hood of distributed systems? Not those “sort of a cluster” setups with 3 nodes, I mean the real deal. The exabyte-scale beasts. In this talk, we’ll peek behind the curtains of modern infrastructure. How do systems that crunch mountains of data actually work? What patterns, principles, and engineering decisions are hiding behind truly scalable architectures? Here’s what we’ll dive into: - What the inner life of a distributed system really looks like - How a distributed app is different from a distributed system - How data storage patterns evolve into modern DBs, queues, and logs - Why “PostgreSQL in the cloud” isn’t really PostgreSQL anymore - Why Northguard might just outshine Kafka - And how new players like NewSQL are changing the game If you’re an architect, tech lead, developer or just curious about why infrastructure scales the way it does - come join! I’ll share insights you might use in your own projects (or at least see them from a new angle). P.S. Yep, there’ll be a bit of magic ✨ and a whole lot of hard truths about the distributed systems powering our world. ?

This presentation will focus on the maintainability quality attribute — how to keep business logic isolated, consolidated, encapsulated, and consistent, as well as how to integrate it with the infrastructure layer, including persistence, messaging etc. We will explore the practical application of the following approaches: - OOD / Rich Domain Model / DDD - Hexagonal layered architecture - CQRS / Persistence / ORM All these aspects will be illustrated through a real-world task example and its implementation approach (code examples will be in .NET).

JavaScript and Golang are two different worlds that often intersect in modern projects: the first dominates frontend development and rapid prototyping, while the second excels in high-load services and microservice architectures. In this talk, I will share my personal experience of moving from JS to Go, comparing approaches to asynchronous programming, application architecture, working with databases, and tooling. We’ll explore not only the differences but also the similarities that help developers adapt more easily between these ecosystems.

This talk explores the journey of growth beyond the Senior Engineer role. Drawing from my own path — from Junior Engineer to leading the Node.js Department — I’ll share personal challenges, lessons learned, and the key turning points that shaped my career. The session will serve as a practical guide for engineers who have reached the senior level and are asking themselves: What’s the next step? We’ll look at both vertical and lateral growth opportunities, from technical mastery to leadership, from becoming an expert to shaping teams and departments.

Imagine you decide to save an old, worn-out ship by replacing its engines with the most advanced ones. But instead of “sailing into a bright future,” it starts sinking even faster. This is a story about how Clean Architecture can become either a life buoy or a stone tied to a project’s neck. The first part is a chronicle of pain: the attempt to bring architectural elegance into the chaos of legacy code, where even successes felt accidental — and why “We’re just doing Clean Architecture” doesn’t always work. The second part is a story of “triumph”: when a mature team and the right approach turned Clean Architecture into the foundation of a scalable, flexible, and truly alive system. Two stories from real practice that show why the same approach can both sink a project and save it.

Expect field-tested patterns, pitfalls to avoid, and ready-to-reuse templates that keep 200+ services running in production without losing your mind.

Launching a Diia AI Against All Odds What does it take to build a conversational AI assistant for millions of citizens? The journey of creating Diia.AI, Ukraine's national digital assistant, started with a simple, promising Proof of Concept. But moving from a controlled demo to a live, production system that handles sensitive data and real-life services was a journey filled with unexpected turbulence. This talk is an honest, behind-the-scenes look at our architectural evolution. We'll dive deep into the real-world challenges we faced: from tackling unpredictable LLM hallucinations and integrating with complex legacy government registries, to designing for national-level security and scale under extreme pressure. This isn't a story of seamless success; it's a story of problems solved, from the absurdly simple to the monumentally complex. Join us to learn the practical lessons that aren't in the textbooks. We will cover how we architected for resilience using a RAG-based approach to fight misinformation, implemented robust Guardrails to ensure safety, and built a scalable, fault-tolerant ecosystem. This session is for any architect, developer, or product leader who wants to understand the battle scars and hard-won insights that come from launching a massive AI platform against all odds.

We wanted to make our service lightning-fast for users anywhere in the world. Edge computing looked like the perfect solution. In practice, we achieved lower latency — but also ran into a whole bunch of unexpected problems. In this talk, Igor will cover: - how they designed edge architecture for global users; - edge providers and infrastructure: what we chose and why; - which optimizations actually made a difference; - architectural trade-offs that shaped our system design; - when edge turned into an “edge-case” and forced us to find unconventional workarounds; - our failures — and the best practices we derived from them.

How to design architecture for a product that already has a successful production environment, but where you still want to launch startup-like initiatives inside it? How do you avoid breaking a stable system, keep user trust, and at the same time give the business room for experiments? - Painful cases of “heavy features” that didn’t stick - How we turned the business desire for “more and faster” into architecture - A successful case of fast features: Secret Boxes in Expirenza - Problems that came after the success of a “temporary” feature - Shifting the development team’s mindset