Vaadin Create /26
Agenda Day 2

In the late 1990s, I was a teenager building data-driven UIs on top of Paradox databases with Delphi. The UI was driven by the database schema. It was ugly. It worked. I was hooked.
I spent the next two decades learning that how you build software matters — not just whether it works. I came to see code as craft. Vaadin then asked me to codify that craft into The Vaadin Way. It was grounded in ten years of real-world screw-ups — and it didn’t go as planned. The craft resisted codification. I was already rethinking the whole approach when AI agents showed up and made the question urgent for everyone.
Today, I have colleagues running unchecked AI-generated code in production. It works. I also have a personal project where an agent writes every line — and I’ve never been more excited about building software. Both are true at the same time, and I don’t think we’re talking enough about what that means.
This is not a talk about how to use AI agents with Vaadin. This is about what happens to craft, experience, and judgment when the machine gets good enough.

Do you think Jakarta EE is just for old-school enterprise backend development? Well, think again! When paired with Vaadin, the Jakarta EE stack becomes a powerhouse for building sophisticated, type-safe web applications entirely in Java.

In this session, we will move past the theory and dive straight into the code. During this talk I will show you how to build a full-stack application from scratch, leveraging Jakarta EE and combining it with Vaadin for a beatiful, component-based frontend without touching a single line of JavaScript or CSS.

• how Vaadin Web Components support a scalable and reusable implementation foundation,
• how component documentation needs to change when its users are both humans and AI agents,
• how MCP connects a Vaadin-based design system with development environments and AI assistants,
• how a chatbot makes design system knowledge easier to access,
• how the approach strengthens collaboration between design and development,
• and which architectural, governance, and accessibility decisions need to be considered.

Learn about new features that make it easy to integrate LLMs into your Flow application and provide your users with features like AI-generated charts and grid, and AI-powered form fillers and filtering UIs.

Learn how to generate Vaadin UI code from a Figma design in two ways. Vaadin Copilot offers a deterministic workflow, while an AI agent combined with Figma MCP provides full flexibility.

Discover how Figma is shaping its product to streamline the designer-developer handoff. We’ll also take a peek at Claude Design and other emerging design tools and explore how they can utilize the Vaadin Design System.

Join an interactive theming and styling session where we’ll work on a Vaadin application live—no slides, just code, CSS, and whatever challenges come our way.
We’ll start with a demo app that could use some visual attention and improve it together. Bring your questions, ideas, and styling challenges: we’ll take requests from the audience and explore how to solve them in practice. Along the way, we’ll look at different approaches to theming and styling Vaadin applications, share useful techniques, and probably encounter a few unexpected CSS puzzles.
We’ll also put AI to work on some of the tasks and see where it genuinely helps—and where doing it yourself still wins.
Come with questions, or just follow along and see where the session takes us.

Vaadin TestBench’s UI unit testing tooling has a new name—browserless testing—and a permissive Apache 2.0 license. The new name reflects its full scope: beyond testing individual UI components, you can write integration and acceptance tests that follow real user stories, all without a browser.
As AI agents take on more development work, fast, reliable tests become an essential feedback loop. This session introduces recent improvements to browserless-test module and practical ways to use it in agent-assisted Vaadin development, helping agents verify their changes against the behavior your users expect.

Draiv is a working name for an experiment that lets AI agents use Vaadin apps through a lightweight scripting language and a text-based view of the UI component tree. The idea is simple: give agents the same capabilities you’ve already built for your human users—without exposing your service layer. The goal is a faster, safer route to agent integration, with less token and CPU overhead than browser automation tools like Playwright.
Combine this with deterministic scripting and scheduling, and you open up new ways to automate your Vaadin apps. Join us for practical demos and learn how to try this experimental technology in your own app.

What does it take to build a zero-dependency, TCK-compliant MicroProfile server from scratch in the age of AI? Meet Vidocq—an open-source project designed to achieve true software sovereignty without relying on massive, opaque third-party dependency chains.

In this session, we will explore the origins of Vidocq and dive into how AI was leveraged as a core engineering partner rather than a mere autocomplete tool. We will examine the specific AI workflows, custom development skills, and automated strategies used to tackle the rigorous Test Compatibility Kit (TCK) requirements. Finally, we'll look at Vidocq's current roadmap and showcase a live demo of Vaadin applications running on the server—complete with live coding if time permits. Join us to see how human architecture combined with AI execution can redefine modern Java runtime development.