Stop Building AI Models. Start Building AI Products - From Demo Applause to Production Value

95% of GenAI projects fail to deliver measurable business returns (MIT Media Lab, 2025). Not because the models don't work—they demo beautifully. They fail because we skip the fundamentals: clear requirements, stakeholder alignment, and product thinking.

This talk challenges the "build a model first" mindset. We'll explore why requirements engineering and understanding business value are more critical for AI projects, not less. You'll learn practical techniques to identify real value and collaborate effectively with stakeholders, defining success before writing a single line of code.

With this foundation, we examine when PoCs are actually needed and how to bridge the dangerous gap between PoC and MVP. But we don't stop there: What does a real product strategy look like? How do we move from one-off experiments to a systemic, transformational approach?

This talk will help you think about getting value out of solutions, where AI is a powerful tool to achieve outcomes, not the business value itself.

Beyond YAML: How We Design OpenAPIs and AsyncAPIs in Workshops

OpenAPI and AsyncAPI are powerful specification languages for REST and event-driven APIs. They're machine-readable and excellent for developers—but when designing APIs collaboratively, the YAML-based standards can overwhelm business stakeholders.

We developed the API Product Canvas to solve this problem: a visual tool that bridges Domain-Driven Design and API specifications. It captures a bounded context and shows both the APIs it provides and those it consumes, combining synchronous and asynchronous interfaces in a single view. For each API, the canvas visualizes aggregates, operations, events, and payloads in a format that IT and business experts can discuss together.

In this talk, we'll share our learnings from running API design workshops across industries. You'll see how the canvas guides teams through designing REST and event-driven APIs—making explicit decisions that often remain implicit until implementation. We'll also demonstrate how to accelerate the workflow by using AI to generate a first OpenAPI or AsyncAPI spec draft directly from the canvas.

You'll leave with a practical methodology for facilitating API design sessions that produce well-architected, business-oriented APIs that everyone involved understands.

Takeaways:
- The API Product Canvas as a visual facilitation tool for collaborative API design
- How to engage non-technical stakeholders in OpenAPI and AsyncAPI specification
- Using AI to generate first API spec drafts from canvas results

Event design with AsyncAPI and DDD

Events are foundational building blocks in modern integration architectures, and they can be transferred and published with the support of event brokers like Apache Kafka. Business events flow between components to exchange information. These events should be used like any other API, and therefore, they should be designed corresponding to the API-first principle as it is applied to synchronous APIs such as RESTful HTTP APIs.
Although this requirement is obvious, specification languages for designing APIs like AsyncAPI are not widely adopted. AsyncAPI is an open-source specification that provides a common language for defining and documenting asynchronous APIs, similar to how OpenAPI (Swagger) works for REST APIs.
Join this session to understand an end-to-end approach, which can be used to design events based on event storming and context maps using AsyncAPI. Additionally, we'll show how modern LLM tools can support the process even further.

Session outline:
1. AsyncAPI – a specification language for events and messages
2. An example with event storming
3. Definition of events out of a context map
4. Definition of the payloads
5. Message or event – that's the question
6. Checklist when and where events can be applied

The audience would come out of the session armed with the knowledge of how to use AsyncAPIs while using Apache Kafka as the message exchange backbone. This session is targeted towards data streaming engineers, architects, and business analysts.

Your Workloads Can Lose Some Weight: WebAssembly on Kubernetes

What if your container image were a few megabytes instead of hundreds? WebAssembly (WASM) offers a radically lighter approach to running workloads on Kubernetes — right alongside your existing containers.
We'll dive into how WASM modules using WebAssembly System Interface (WASI) integrate into Kubernetes through containerd shims like runwasi. Using a Rust example, we'll demonstrate the dramatic reduction in image size and startup time compared to traditional containers. We'll explore what's production-ready today and where you should wait before adopting.
Beyond basics, we'll look at CNCF projects already running WASM in production and discuss where WebAssembly shines: plugin architectures benefiting from small, secure, sandboxed extensibility, and event-driven systems that scale quickly from zero. Whether optimizing for resource efficiency or exploring new isolation patterns, this session provides practical insights into WebAssembly on Kubernetes.

Kubernetes Saved My Grandma: High-Reliability IoT for Elderly Care

Our home emergency system saves lives on AWS – and it works brilliantly. But what if we needed to run it independently? Join a CARU engineer and a CNCF Ambassador as they explore what a truly sovereign, open-source alternative would look like – without compromising the reliability our users depend on.

At CARU, our home emergency system protects elderly people living independently. When lives are at stake, reliability isn't optional – it's everything. We built our architecture on AWS managed services, and honestly? It works.
But as engineers, we ask uncomfortable questions: What if regulations change? What if geopolitical shifts make US cloud dependency a business risk? We don't have these problems today, but responsible architects prepare for tomorrow.
In this session, we turn the stage into an architecture exploration room. Starting from a production IoT system, we'll investigate what it would actually take to achieve full sovereignty using open-source, Cloud Native technologies.

Crafting Great APIs with Domain-Driven Design

Most APIs fail not because of technical shortcomings, but because they don't reflect the business domain they're meant to serve. We end up with generic CRUD endpoints that leak implementation details, tightly couple consumers to our internal models, and crumble when requirements evolve.

Domain-Driven Design offers a way out—but applying DDD to API design requires more than just naming conventions. It demands a collaborative methodology that bridges the gap between business stakeholders and technical implementation.

In this session, we'll explore a practical approach to crafting APIs that truly represent your domain. Starting with Domain Stories to capture business workflows, we'll derive a Visual Glossary that establishes a shared Ubiquitous Language. From there, we'll use the API Product Canvas to shape APIs as products—with clear boundaries, consumer, and focus.

But great APIs aren't just request-response. Therefore, this approach covers a streamlined way to identify and design both synchronous and asynchronous APIs.

We'll walk through a complete design journey: from Business Model Canvas through strategic design with capability mapping and Domain Storytelling, to tactical design with Event Storming and Visual Glossary, and finally to an API specification in OpenAPI or AsyncAPI—accelerated by LLMs.

An Introduction to Helm 4: Simplifying Kubernetes Resource Management

Kubernetes is an excellent tool for container orchestration, but managing configurations and deployments manually can become cumbersome as your environment grows. Helm simplifies this process by introducing the concept of "charts" — reusable, templated packages that make deployments configurable, repeatable, and manageable.
In this talk, we will explore Helm, a graduated CNCF project, and its capabilities. We will show how to work with it, best practices, how to avoid common pitfalls, how you can publish your own charts, and how to integrate it into your development workflow.
Along the way, we'll highlight what's new in Helm 4: WebAssembly-based plugins, server-side apply, improved deployment monitoring with kstatus, and faster caching. At the end, we also take a look at helmfile and how it can improve your Helm and Kubernetes experience even more.

When to select which communication protocol? A landscape for protocols and integration architecture

When starting with an integration between applications, we can be overwhelmed by the number of protocols available. The criteria "What do I know already?" or "What is trendy?" will often guide us. But are there better criteria for selecting the best protocol for a use case?
In this talk, we will share our approach to categorizing and selecting protocols depending on the integration pattern needed, the business requirements, and suitability.
We will show methodologies like DDD and context maps that can help us find the best-suited protocol; we will include HTTP, gRPC, GraphQL, MQTT, AMQP, WebSocket, SSE, Kafka, NATS, etc.

From Chaos to Clarity: Designing Beautiful APIs Through Collaboration, DDD, and AI

How do you craft great APIs — ones that are intuitive, self-explanatory, and truly aligned with business goals? Too often, APIs reflect technical constraints rather than the shared understanding of the domain they serve. In this talk, we’ll explore how to bridge that gap and collaboratively design APIs that both developers and business stakeholders love — this time, with the help of Large Language Models (LLMs).

We’ll demonstrate how Domain Storytelling and Event Storming, supported by Domain-Driven Design (DDD) principles and guided by AI assistants, can help teams uncover the real business needs behind an API. You’ll see how LLMs can facilitate workshops, refine domain language, and even generate draft OpenAPI or AsyncAPI specifications that reflect the modeled understanding — whether the interfaces are synchronous or asynchronous.

By the end of this session, you’ll learn how to combine human collaboration and AI augmentation to move from fuzzy business conversations to concrete, elegant API designs that are both technically sound and business-aligned.

Key Takeaways:

- How DDD principles guide you from domain insights to structured, purposeful API designs.
- How LLMs can support the process — facilitating sessions, refining models, and accelerating the creation of API specifications.
- Practical examples of combining human creativity with AI-assisted design for faster, higher-quality API outcomes.

DevOps for AI: Beyond the Model with Collaboration and Automation

Despite massive investments in AI, most enterprise AI projects still fail to reach production, as confirmed by recent studies from MIT and industry analysts. The failure point isn't the technology - it's the disconnect between data science teams, engineering workflows, and business stakeholders. MLOps bridges this critical gap by bringing DevOps principles to AI/ML systems, but it's more than just technical operations - it's about creating alignment between technology teams and business objectives to ensure AI delivers real value.
This talk presents strategies and thoughts for building production-ready AI systems through effective requirements gathering and MLOps practices. We'll walk through a complete end-to-end MLOps pipeline, demonstrating how automation and continuous feedback loops transform experimental models into reliable production services.
We'll leverage the CNCF ecosystem—particularly Kubeflow and cloud-native tooling—to build vendor-neutral, multi-cloud solutions that scale with enterprise needs. Whether you're getting started with MLOps or optimizing existing workflows, you'll leave with actionable strategies to overcome the most common roadblocks in AI deployment.

Crafting Great APIs with DDD

How do you craft great APIs?
How is it self-explanatory and straightforward to use?
Will it cover the business needs?
Is the interface synchronous or asynchronous?

We will discuss these questions and show how business and IT can build beautiful APIs in collaboration. We will introduce you to domain storytelling and event-storming methods in conjunction with domain-driven design (DDD). We will also explain how these methods can help derive designs for synchronous and asynchronous interfaces.

Supercharging Edge Event-Driven Architecture on Kubernetes with Wasm

In this talk, we will explore the transformative potential of WebAssembly (WASM) in enhancing event-driven deployments. We will begin by examining the current state of WebAssembly in conjunction with Kubernetes, Knative, and KEDA, providing an overview of its capabilities within the CNCF ecosystem. We will focus on building autoscaling event processing systems, highlighted by a practical example using Kafka. We will also discuss the benefits and challenges associated with this approach. Join us to discover the exciting possibilities that WASM offers now and in the future to create more efficient and faster large-scale event processing systems.

Crafting Great APIs with DDD

How do you craft great APIs? How is it self-explanatory and straightforward to use? Will it cover the business needs? Is the interface synchronous or asynchronous?
We will discuss these questions and show how business and IT can build beautiful APIs in collaboration. We will introduce you to Domain Storytelling and Event Storming methods in conjunction with domain-driven design (DDD) and explain how these methods can help to derive designs for synchronous and asynchronous interfaces.

Full speed ahead! - How to steer a 130-year-old world-leading insurance business towards simplicity

Embark with us on the journey of how to simplify a complex landscape in a 130-year-old world-leading insurance powerhouse.

Business has the urgent need to adapt quickly and efficiently to new challenges and customer needs. For that reason, we implemented an event-driven architecture (EDA) based on verticals & microservices.

Discussing the issues to be solved and hurdles to be taken in order to implement event-driven architecture in a complex landscape.

We want to demonstrate our ideas, mindset, approaches, and solutions for various aspects of a complex corporate environment. Thus, you might benefit from our lessons learned and get some inspiration for your transformation journey.

We’ll put a spotlight on our methods for communication, mindset change, technical enablement, training, governance, and onboarding for you to get some inspiration.

Join us on our journey!

Cutting Edge Event Driven Architecture on Kubernetes: Taking Wasm for a Spin

Event-driven architectures are becoming increasingly popular for building scalable and responsive systems. In this talk we will explore how WebAssembly (WASM) can enhance event-driven architecture on Kubernetes when combined with Knative and KEDA. We'll focus on building autoscaling event processing systems, showcasing practical examples, and discussing the benefits and challenges of this approach. Join us to learn about the exciting possibilities of integrating WASM into Kubernetes environments for more efficient and faster event processing at scale.

An introduction to Helm

In this talk, we will explore Helm 3, a graduated CNCF project, and its capabilities. We will show how to work with it, best practices, how to avoid common pitfalls, how you can publish your own charts, and how to integrate it into your development workflow. At the end, we also take a look at helmfile and how it can improve your helm and Kubernetes experience even more.

Domain-driven API Design

Der Vortrag diskutiert diese Fragen anhand eines Beispiels. Es werden die Methoden Domain Storytelling und Event Storming benutzt. Aus der daraus folgenden Context Map entstehen schöne APIs, die Entwickler nicht hassen.

1. Einführung in das Beispiel "Online Bibliothek" mit Domain Storytelling und Visual Glossary
2. Context Map auf der Basis eines Event Stormings
3. Diskussion der notwendigen Schnittstellen - synchron und asynchron
4. Skeleton der Schnittstellen mit KI
5. Anpassen der Schnittstellen und Mockup
6. Fazit und weiteres Vorgehen

Einführung in Helm: Die bessere Art Kubernetes-Anwendungen zu managen

Kubernetes ist eines der verbreiteten Container Orchestration Systeme. Doch das Bereitstellen von Ressourcen via YAML-Manifesten ist nicht immer einfach. Oft endet es in viel Copy-Paste und nicht immer nachvollziehbaren Anpassungen.

Dieses Problem kann umgangen werden, wenn man die Kubernetes Manifeste wie Applikationen als Pakete deployed und verwaltet. Dies ist mit Helm möglich!

In diesem Vortrag werden wir Helm 3 genauer unter die Lupe nehmen. Helm ist ein Open Source Projekt, das von der Cloud Native Computing Foundation (CNCF) betreut wird. Es hat den Graduated-Level erreicht, was bedeutet, dass es von der CNCF als stabil und bereit für den produktiven Einsatz ist. Helm dient als Paketmanager für Kubernetes und bietet leistungsstarke Funktionen zur Verwaltung von Kubernetes-Ressourcen, gesamten Anwendungen und ihren Abhängigkeiten. Wir lernen mit Helm 3 zu arbeiten und lernen Best-Practices kennen. Zusammen lernen wir auch mit Tücken umzugehen.

Helm verwendet Charts zur Verwaltung von Applikationen. Wir gehen durch den Chart Erstellungsprozess, lernen kennen, wie man Charts anpassen, diese in eine CI/CD Prozess einbinden und veröffentlichen kann. Am Ende werfen wir auch einen Blick auf helmfile und schauen, wie es den Helm- und Kubernetes-Umgang noch weiter vereinfachen kann.

Streaming & Eventing for Top Management

Developers love event-driven architecture (EDA) and streaming with the latest technologies—and they’re often the easiest to evangelize.

The real challenge lies in convincing top management and C-level executives of the value of reinvesting in yet another emerging technology and understanding the paradigm shift it brings.

At Allianz in Germany, we've spent years driving the transformation to EDA. Our journey has involved convincing stakeholders at all levels—including upper management—of its tangible business benefits.

In this talk, we’ll share our strategy for promoting EDA across the organization, with a focus on how we successfully communicate its value to top decision-makers.

Key Takeaways:

✅ Different stakeholders require tailored messaging—one size does not fit all.

✅ Communication is critical: leverage all available formats and speak about your topic frequently.

✅ Business cases from other companies are helpful, but internal success stories are even more powerful.

✅ Go beyond technology—tie EDA directly to business processes and outcomes.

https://events.pinetool.ai/3500/#sessions/111898?referrer%5Bpathname%5D=%2Fsessions&referrer%5Bsearch%5D=&referrer%5Btitle%5D=Sessions