Session descriptions
Opening
Welcome to Vaadin Create 2026
Explore the future of business app development with Vaadin and Spring.From AI-powered productivity and the latest in Vaadin 25 - Flow, Design System, Modernization, and Copilot—to new advances in Spring Boot and Spring AI. Get inspired by how innovation is reshaping enterprise Java development.
Steven Grandchamp
CEO, Vaadin
Community
Spec-Driven Development - Why Vaadin Is the Perfect Fit
AI makes coding faster, but speed does not solve the real problem: specifications and implementation drifting apart.
This session shows a practical spec-driven approach based on the AI Unified Process, where structured requirements
and system use cases drive the application, and AI generates and evolves code from them incrementally.
You will see why Vaadin is particularly well suited for AI-driven development. Its server-side model, type safety,
and unified Java stack give AI agents a consistent and predictable environment to generate UI and backend together,
without the complexity of fragmented frontend stacks. This improves traceability, stability, and maintainability.
Using real examples, the talk demonstrates how specifications drive UI creation, how guardrails keep architecture consistent,
and how Vaadin enables efficient AI-assisted development of real enterprise applications.
Simon Martinelli
Programming Architect, Martinelli LLC
Community
Turning Vaadin into a Dynamic Enterprise Platform Through Metadata
Most Vaadin applications are built around manually coded CRUD views. But what happens when the representation of your frontend no longer lives in source code?
In this session, I’ll present how we transformed Vaadin into a fully dynamic, metadata-driven enterprise platform powering a real production ERP system. In our architecture, UI structure, navigation, validation rules, and workflows are not implemented in a specific programming language — they are fully structured metadata that anyone can read, understand, and evolve.
In other words, your UI stops being code and becomes data.
But the model goes further. Metadata does not only describe menus and forms — it also defines interactive business processes: batch operations that transform datasets, generate invoices, update pricing rules, apply discounts, and execute complex logic dynamically.
This makes it possible to implement and evolve a complete ERP system without modifying the core application code — everything is defined through metadata.
Vaadin acts as the runtime engine that interprets and executes this metadata in real time, generating both user interfaces and business operations. We’ll explore the architectural patterns behind this approach, including multi-tenant isolation, EDIT/PROD separation, Kubernetes-based scaling, and the performance trade-offs learned from running this model in production.
In this session, I’ll present how we transformed Vaadin into a fully dynamic, metadata-driven enterprise platform powering a real production ERP system. In our architecture, UI structure, navigation, validation rules, and workflows are not implemented in a specific programming language — they are fully structured metadata that anyone can read, understand, and evolve.
In other words, your UI stops being code and becomes data.
But the model goes further. Metadata does not only describe menus and forms — it also defines interactive business processes: batch operations that transform datasets, generate invoices, update pricing rules, apply discounts, and execute complex logic dynamically.
This makes it possible to implement and evolve a complete ERP system without modifying the core application code — everything is defined through metadata.
Vaadin acts as the runtime engine that interprets and executes this metadata in real time, generating both user interfaces and business operations. We’ll explore the architectural patterns behind this approach, including multi-tenant isolation, EDIT/PROD separation, Kubernetes-based scaling, and the performance trade-offs learned from running this model in production.
César Quinteiro Rendo
CTO, Intergal S.Coop.G.
Community
Creating a perfect container image for Java application
In this session, we’ll treat container images like a product with clear requirements. Using a full-stack Spring Boot app with the Vaadin-based frontend, we will explore build and packaging approaches and their real-world implications in terms of startup speed, memory footprint, security posture, and scaling convenience.
In the end, you’ll get a practical playbook for designing Java images based on your goals, including a decision framework and a reusable checklist.
In the end, you’ll get a practical playbook for designing Java images based on your goals, including a decision framework and a reusable checklist.
Catherine Edelveis
DevRel, BellSoft
Community
Transforming the Public Sector From Vaadin 8 to 25
Modernizing public sector applications is rarely just about code; it’s a marathon of managing technical debt and long-term vision. This session explores a nearly decade-long journey of rescuing mission-critical systems from legacy JSP and fragmented JavaScript, evolving them through the Vaadin ecosystem from version 8 all the way to 25.
You will see why Vaadin remains the strategic choice for Java-centric teams in 2026. We will break down how its component-based model bridges the gap between backend expertise and modern UI requirements, ensuring cross-browser stability and meeting strict accessibility (WCAG) standards by default—all without the overhead of traditional frontend silos.
Using real-world migration patterns, the talk demonstrates a practical blueprint for decoupling from legacy JS while maintaining system resilience. We will also discuss how our validation strategy evolved to safeguard applications serving thousands of citizens. In the end, you’ll walk away with a roadmap for long-term modernization that stays performant, inclusive, and maintainable.
You will see why Vaadin remains the strategic choice for Java-centric teams in 2026. We will break down how its component-based model bridges the gap between backend expertise and modern UI requirements, ensuring cross-browser stability and meeting strict accessibility (WCAG) standards by default—all without the overhead of traditional frontend silos.
Using real-world migration patterns, the talk demonstrates a practical blueprint for decoupling from legacy JS while maintaining system resilience. We will also discuss how our validation strategy evolved to safeguard applications serving thousands of citizens. In the end, you’ll walk away with a roadmap for long-term modernization that stays performant, inclusive, and maintainable.
Rafael Molina
Tech Architecture Assoc Manager, Accenture
Juanma Cintas
Tech Architecture Assoc Manager, Accenture
Community
A Type Safe I18N Solution with Vaadin Flow
Currently if building i18n GUIs, the only option built into Vaadin, is using the traditional string-based approach with ResourceBundles. That means, you define keys for all GUI elements which need to be offered in multiple languages and create ResourceBundles for each supported language where you place the keys with the desired translated text. The drawback is, that this solution is not compile-safe and that keys can be missing in the bundle, which leads to missing translations during runtime. In GWT there was a mechanism with annotations and interfaces which allowed a compile-safe solution. Our company built a software with Vaadin, where this issue was addressed and a solution was implemented based on the GWT idea, which will be presented in the talk.
Rüdiger Schobbert
Senior Java Developer, emesit GmbH & Co. KG
Community
“I wonder if it can do that?” - Accelerating Software Development through Curiosity
Lighthouse, our ERP and customer portal for energy consultancy, started as a small proof of concept — the kind of project that, in a normal budget cycle, grows slowly and expensively, eating well over 10% of annual revenue for years before it would earns its keep. Instead, it became a rapidly evolving, multi-featured platform now in daily production use. The difference wasn't a bigger budget. It was a change in reflex.
Normally, when a task turns into a chore, it gets parked. This time, every chore became a question: can AI do this instead? That question, asked repeatedly and without a fixed plan, led to an entire AI-assisted development supply chain: tools for planning work before code gets written, techniques for escaping the endless debugging loops AI happily generates on its own, and methods for keeping UX design from drifting apart as features pile up.
This talk is not a best-practices guide. It's a tour of the engine room — including the wrong turns, the dead ends, and the times it broke — from someone who followed curiosity further than intended and ended up with a platform to show for it.
Marc Müller-Stoffels
Managing Partner, En-Concept® Energy Consultancy GmbH
