Vaadin 24.8 introduces improvements across the platform that make everyday development tasks faster and more reliable. From layout and file-handling improvements to database devops and type safety, this release adds tools that help you build and maintain modern Java applications with less friction—and fewer surprises.
Here’s what’s new across the stack.
Flow updates: File handling, signals, and more
Flow 24.8 introduces a preview of reactive state management—offering a simpler, more declarative way to build backend-driven UIs in plain Java. Alongside that, it includes smaller API and tooling improvements that reduce boilerplate and give you more control during development.
Reactive UI state with signals (Preview)
A new experimental API introduces reactive state management for Flow. It allows views to automatically update in response to any state change. This feature is available under a feature flag and gives a first look at Flow's direction toward taking UI state management to the next level.
```java
NumberSignal count = new NumberSignal();
Button countButton = new Button();
countButton.addClickListener(click -> count.incrementBy(1));
ComponentEffect.format(countButton, Button::setText, "Click count: %.0f", count);
```
Simplified upload and download handling
File upload and download APIs in Flow now align more closely with standard HTTP request handling. Helper methods reduce the boilerplate typically involved in accepting uploads or serving downloads.
More flexible @PreserveOnRefresh
The @PreserveOnRefresh annotation can now be configured to work even when the route chain only partially matches. This improves behavior in dynamic navigation flows and multi-step views where exact routing isn’t certain.
Optional full page reloads during hot swap
You can now enable full page reloads in development mode via the system property -Dvaadin.hotswap.fullPageReload=true. This gives you more control over how your app handles code changes during hot deployment.
Jackson replaces Elemental JSON for JSON handling
Flow is migrating from Elemental JSON to Jackson for JSON processing in both the public API and internal implementation. This improves compatibility with common Java tooling and makes JSON serialization more consistent.
Hilla updates: better localization, routing, and DX
Hilla 24.8 brings focused updates to areas such as localization, routing, and type safety—resulting in less boilerplate and smoother day-to-day development.
Translation API
The new server-side Translation API simplifies localization by letting you manage view translations using the same resource bundles that you use from server-side Java.
```javascript
return <div>{translate(key`addresses.form.city.label`)}</div>;
```
Lazy loading in the file-system router
Views are lazy-loaded to reduce initial JavaScript bundle size, improving startup performance in larger applications.
Custom metadata in routes
File-based routes support custom metadata for building dynamic menus, managing custom permissions, or adding SEO-related configuration—without extra boilerplate.
Improved Kotlin–TypeScript type generation
TypeScript types generated from Kotlin code now reflect nullability annotations, improving type safety across the stack.
Service Worker support for endpoints
Allows using Hilla's browser callable service endpoints from Service Workers. This can be used to enable limited offline functionality in PWAs.
Custom HTTP status codes in endpoints
Endpoints now support returning custom HTTP status codes, giving you more control over API behavior and error handling.
Built-in empty state for AutoGrid
AutoGrid now includes a default empty state when no data is available—eliminating the need for manual placeholder logic.
Modernization Toolkit: Reaching 80% Vaadin 7 coverage
The Modernization Toolkit continues to grow. With the 24.8 release, we've added another chunk of legacy Vaadin 7 components and APIs—bringing the total coverage to an estimated 80% for typical Vaadin 7 applications.
This update builds on the 24.7 release by adding support for key UI components, data binding APIs, and layout abstractions that didn’t make the previous cut.
Notable additions in 24.8:
- Components: Vaadin 7 Button, Grid, ListSelect, TabSheet, TokenField, and TwinColSelect
- Abstractions: Sizeable and HasSizeable
- Data: Logical Filters (Not, Or, Between etc), Sorting, and ItemDataProvider
Still on Vaadin 7 or 8? Try the free analyzer and get a report with automation estimates for your migration. Run the analyzer with the tool of your choice; Maven or Eclipse.
Vaadin Copilot: Better support for custom components
Vaadin Copilot in 24.8 introduces improvements that make it more practical to use in projects with custom components—especially when you’ve built your own UI building blocks or design system.
Improved support for custom and composite components
You can now drag and drop custom and composite components onto the canvas and edit their properties more easily. Copilot handles components that extend base classes or act as top-level views more reliably, reducing friction when working with real-world apps.
Properties Editor
The new Properties Editor makes it easier to configure components in Copilot. It exposes properties that aren’t directly editable on the canvas—like text content, layout settings, and custom attributes—so you can make adjustments visually without switching to code for every change.
Create a View based on an image
Whether you're modernizing an old view or building something new, you can start by providing an image of the desired UI. Copilot sets up the layout and components based on the image, so you can jump straight into refining the details and working on the business logic.
Create a JPA service, repository, and entity with sample data
When building a new view with a Grid, you often need a data entity to populate it. Copilot can now generate a complete starting point, including a JPA entity, repository, and service, when using Spring Data. It can also add realistic sample data to make the view usable right away, which is helpful when testing or fine-tuning layouts during development.
These updates make Copilot more useful in day-to-day development, particularly when working in projects that rely on shared components or custom frameworks.
Design System: New form layout model, Markdown support, and more
Vaadin Design System in 24.8 introduces layout improvements, new content rendering capabilities, and enhancements to core components—all designed to help you build structured, flexible UIs with less effort.
Form Layout: New layout model
The Form Layout component now has a new layout model that makes it easy to create responsive forms with any number of columns without manually defining breakpoints, and gives developers more control over the way fields are grouped into rows. The old layout model remains available for backward compatibility.
```java
FormLayout formlayout = new FormLayout();
formLayout.setAutoResponsive(true);
formLayout.setColumnWidth("8em");
formLayout.addFormRow(new TextField("First name"), new TextField("Last name"));
formLayout.addFormRow(new EmailField("Email address"));
formLayout.addFormRow(new PasswordField("Password"), new PasswordField("Confirm password"));
```
Markdown component
You can now render Markdown directly in your UI with the new Markdown component. It makes it easy to add formatted text to your UI, including lists and simple tables, with a lightweight markup instead of HTML, and can be useful for embedding content generated by AIs. The MessageList component also gains support for Markdown.
```java
Markdown markdown = new Markdown("""
## Rich Text Formatting
You can create **bold text**, *italicized text*, and `inline code` with simple Markdown syntax.
### Ordered List:
1. First item
2. Second item
3. Third item with **bold text**
""");
```
Dashboard component is now stable
The Dashboard component is now out of preview and safe for production use. Alongside stabilizing its core APIs, we’ve added support for setting heading levels on widget titles—improving accessibility and document structure. It's ready to support more complex dashboards and enterprise-grade use cases.
Master-Detail Layout (Preview)
This new component helps you build responsive master-detail interfaces without custom layout logic. It adapts based on screen size and works well for common UI patterns in data-heavy apps, like editable lists or admin views.
Support for polygons in Map component
The Map component now supports rendering polygons to highlight areas on the map, such as geographical features, zones or corridors.
Updates to existing components
Several components received enhancements that improve usability, customization, or data handling:
- Card is now available in Flow, making it easier to structure content into visual blocks.
- Message List supports Markdown and append-text APIs necessary for streaming AI-generated rich text content, making it ideal for AI-based chats.
- Date-Time Picker now offers improved validation behavior for a smoother user experience.
These updates help reduce the need for custom components and CSS tweaks, while giving you more flexibility and control in building polished, accessible UIs.
Database Management in Control Center
Vaadin 24.8 introduces new built-in capabilities in Control Center for managing PostgreSQL databases. You can now provision a database per application, run schema migrations, and manage backups—directly from the Control Center interface.
These features are designed to streamline operations and reduce the need for custom scripts or manual infrastructure setup, making it easier to deploy and maintain Vaadin applications in Kubernetes environments.
Automatic PostgreSQL provisioning
Each deployed application can be connected to a dedicated PostgreSQL instance. The database is provisioned and configured automatically, and a Spring-compatible DataSource bean is made available for injection into your services and views.
Flyway-based schema migrations
Database schema changes can be managed using Flyway migrations placed under src/main/resources/db/migration. Migrations are applied automatically on startup, and their status is visible in the Control Center UI.
On-demand and scheduled backups
Control Center supports both manual and scheduled backups using CloudNativePG. Backups can be stored on Kubernetes volumes or external object storage (such as AWS S3). This ensures your application data is protected and recoverable.
Other improvements
Vaadin 24.8 also includes a number of quality-of-life improvements across the platform:
Faster builds for Maven and Gradle
The vaadin:prepare-frontend and vaadin:build-frontend goals in the Maven plugin have been optimized for faster execution. Gradle users can now benefit from the configuration cache, reducing build time and improving startup speed—especially in larger projects.
Better test authoring in TestBench
TestBench now includes new shorthand methods and mixins for TestBenchElement, making test code more concise and easier to read.
🎙️ Join the live Vaadin 24.8 release webinar
We’re hosting a live walkthrough of Vaadin 24.8 on Wednesday, June 25 at 18:30 CEST / 9:30 AM PDT. In this session, we’ll cover all the key updates—from Signals and Markdown to PostgreSQL provisioning in Control Center—and share insights behind the changes.
No registration needed—just join us on YouTube and bring your questions.
📺 Watch live on YouTube
📅 Add to calendar
Ready to upgrade?
Vaadin 24.8 adds new components, improves everyday APIs, and gives you more built-in tooling to handle real project needs—from layout and routing to backups and schema updates. If you’re already on Vaadin 24, upgrading is as simple as updating your version in pom.xml.
Check out the release notes for full details, and let us know what you think in the Vaadin Forum or on GitHub.