Mateu
Build backoffice UIs without building a frontend
Mateu is a backend-driven UI layer for distributed systems.
Define your business UI once in Java.
Mateu generates forms, CRUD, navigation and application shells from that model.
@UI("/orders")
public class Orders extends AutoCrudOrchestrator<Order> {}
- no frontend app to build
- no duplicated models
- stateless by design
- works with your existing Java backend
The problem
Most business applications end up with two applications:
backend → API → frontend → duplicated model → duplicated validation
That usually means:
- duplicated business concepts
- duplicated validation
- more glue code
- more moving parts
- harder maintenance
The Mateu approach
backend → Mateu UI → browser
The backend owns the UI.
Mateu lets your backend expose real business UIs directly, without turning every internal tool into a separate frontend project.
Built for real architectures
Mateu fits naturally in systems built with:
- microservices
- DDD
- CQRS
- hexagonal architecture
- workflow-driven applications
User → Mateu UI → Application use cases → Domain
Mateu is stateless:
- no server-side UI sessions
- no sticky sessions
- no per-user UI memory
- horizontally scalable
Works with your stack
Mateu does not force a specific backend framework.
You can use it with:
- Spring Boot MVC
- Spring WebFlux
- Micronaut
- Quarkus
- any HTTP-based Java backend
You keep your architecture. Mateu becomes one more inbound adapter.
Bring your own frontend
Mateu separates UI definition from UI rendering.
Your UI is defined in Java, but rendered by a frontend.
That means you can use:
- different design systems
- different frontend implementations
- different rendering strategies
Mateu defines what the UI is, not how it must look.
Mental model
State → Actions → Routes → UI
- State → fields
- Actions → methods, buttons, callables
- Routes → navigation
- UI → generated and rendered automatically
What you can build
Admin panels
Fast CRUD-heavy backoffice screens directly from your Java model.
Distributed backoffices
Let each microservice define its own UI and compose everything in one shell.
Embedded UI
Use Mateu inside React, Vue, Angular or plain HTML through a web component.
Real-world architecture
Mateu treats UI as an inbound adapter:
Infrastructure / in
├─ api
├─ async consumers
└─ ui ← Mateu
This makes Mateu a natural fit for backend teams building business systems.
Comparison
| Approach | Typical trade-off |
|---|---|
| React / SPA | frontend-heavy, duplicated models |
| Vaadin | stateful server-side UI session |
| CRUD generators | fast start, limited flexibility |
| Mateu | stateless, backend-driven, distributed UI |
Recommended path
- Quickstart
- Admin panel
- Customizing CRUD and listings
- Golden example: Orders, Customers and Order lines
- Real-world architecture
One-sentence summary
Mateu turns backend models into real distributed business UIs, without requiring a frontend stack.
Community
Mateu is evolving. Join the community: