Why Frameworks Like Jmix Dramatically Accelerate Enterprise Application Development and How to Implement an Employee Expense Management Application in just One Hours using Jmix

One of the most important lessons learned from modern AI-assisted software development is that productivity is not determined solely by the capabilities of the AI. The underlying framework and architectural foundation play an equally important role.

When building enterprise applications, developers often spend a significant amount of time implementing infrastructure rather than business functionality. CRUD operations, security, authentication, user management, data binding, transactions, file handling, auditing, navigation, and UI generation are repeated in project after project. Although these tasks are necessary, they rarely provide direct business value.

This is where Jmix offers a significant advantage.

Built entirely on Java and Spring Boot technologies, Jmix provides a complete application development platform that allows developers to focus primarily on business requirements rather than technical plumbing. Data models, database mappings, user interfaces, security, workflows, and administration capabilities can be generated and extended rapidly while remaining fully customizable.

One of the most remarkable aspects of Jmix is the balance it achieves between productivity and flexibility. Unlike many low-code platforms, developers are not locked into proprietary languages or runtime environments. Everything remains standard Java, making the generated applications easy to understand, maintain, debug, and extend by any experienced Java developer.

The productivity gains become even more evident when Jmix is combined with AI-assisted development. AI can generate entities, business rules, views, workflows, and user interfaces, while Jmix provides the framework necessary to integrate these components into a consistent and maintainable enterprise application. This combination significantly reduces development time while also reducing implementation errors and architectural inconsistencies.

Another differentiating factor is the breadth of functionality available within a single platform. Very few Java-based frameworks provide integrated support for features such as:

Business Process Management (BPM)
Workflow automation
Kanban boards
Role-based security
File storage and document management
User and access administration
Audit trails
Dynamic user interfaces
Reporting and dashboards
Data management and CRUD generation

Traditionally, implementing these capabilities requires integrating multiple frameworks and libraries, each with its own configuration, lifecycle, dependencies, and learning curve. Jmix consolidates many of these concerns into a unified and coherent development model.

For development teams, this translates into several tangible benefits:

Faster application delivery
Lower development and maintenance costs
Reduced implementation risk
Fewer integration problems
Consistent architectural patterns
Easier onboarding of new developers
Higher code quality and maintainability

In a software industry increasingly influenced by AI-generated code, frameworks such as Jmix become powerful multipliers. They provide the structure, conventions, and enterprise capabilities that allow both developers and AI agents to produce high-quality business applications in a fraction of the time traditionally required.

The result is not only faster development, but also more reliable, maintainable, and scalable enterprise software.

One of the most important aspects of Jmix is that it is not a limiting platform. Unlike many low-code environments that lock developers into proprietary technologies and development models, Jmix is built entirely on standard Java and Spring Boot technologies.

This means that developers can fully benefit from the productivity gains provided by Jmix during the initial stages of a project while retaining complete control over the application's future evolution. If additional functionality is required beyond what Jmix provides out of the box, developers can seamlessly implement custom Spring services, integrate external systems, expose REST or GraphQL APIs, incorporate third-party Java libraries, or build highly specialized user interfaces.

In fact, one of the greatest advantages of Jmix is that it accelerates the development of the repetitive and infrastructure-heavy parts of an enterprise application while preserving the full flexibility of the underlying Spring ecosystem. The most time-consuming tasks—data management, security, user administration, navigation, CRUD operations, workflows, and application structure—are already solved. From that point forward, the development team is free to extend the application as far as business requirements demand.

In other words, adopting Jmix is not a technological compromise. It is a way to complete the hardest and most repetitive parts of enterprise software development faster, while keeping all the power and flexibility of the Java and Spring Boot ecosystem available whenever it is needed.

Creating the Employee Expense Management Application in Just One Hour Using Jmix. Without AI Assistence.

In the previous article, "How to Implement an Employee Expense Management Application in Two Hours with AI Assistance", we designed and implemented a complete expense management solution using a traditional enterprise architecture based on a relational database, Spring Boot, GraphQL, and React.

In this second exercise, the objective was different: to evaluate how much development effort could be reduced by leveraging a framework specifically designed for rapid enterprise application development.

The result was remarkable. Starting from the database schema created in the previous article, a fully functional application was built in approximately one hour using Jmix.

Starting Point: Reusing the Existing Database

Unlike the previous implementation, no database design work was required.

The application was built directly on top of the existing Oracle database schema containing the following tables:

EXPENSE_SHEET
EXPENSE_LINE

Since the database structure had already been validated, the focus shifted entirely to the application layer.

Step 1: Creating the Entity Model

The first step consisted of creating the JPA entities representing the business model.

Rather than designing a new model from scratch, the existing entity classes from the previous Spring Boot implementation were reused and adapted to Jmix.

Only minor modifications were required:

Adding Jmix entity annotations.
Adjusting date and time types.
Implementing Jmix-compatible enumerations.
Defining the master-detail relationship between ExpenseSheet and ExpenseLine.

The resulting model consisted of only two entities:

ExpenseSheet

Represents an employee expense report and contains:

Sheet Number
Employee Name
Sheet Date
Currency
Status
Total Amount
Responsible Person
Comments

It also owns a collection of ExpenseLine entities through a composition relationship.

ExpenseLine

Represents an individual expense item and contains:

Expense Date
Expense Type
Description
VAT Rate
Amount
Payment Method
Receipt File Name

This entity is linked to its parent ExpenseSheet through a standard master-detail relationship.

Step 2: Reusing Existing Enumerations

The enumerations created in the original application were reused with minimal changes.

The following business enumerations were preserved:

ExpenseStatus
ExpenseType
PaymentMethod
CurrencyCode

Only the implementation was adapted to conform to the Jmix EnumClass model, allowing automatic integration with:

Combo boxes
Filters
Forms
Data grids
Validation mechanisms

This avoided the need to recreate business rules already implemented in the original application.

Step 3: Generating the User Interface

One of the most significant productivity gains came from Jmix's ability to generate complete CRUD interfaces directly from the entity model.

Instead of manually developing pages, components, controllers, APIs, GraphQL schemas, DTOs, mappers, and frontend code, the application was generated directly from the entities.

Official Jmix Documentation

The following views were created.

Expense Sheets List View

Features included:

Data grid
Column sorting
Generic filtering
Column resizing
Column reordering
Create, Edit, Delete, and Refresh actions

The view was generated automatically and required only minor cosmetic adjustments.

Expense Sheet Detail View

This view contains:

Expense Sheet header information
Employee details
Status and currency selectors
Total amount calculation
Comments section

The detail form serves as the master component of the application.

Expense Lines Embedded Grid

A grid containing all expense lines associated with the selected expense sheet was added directly below the form.

Features include:

Create line
Edit line
Remove line
Sorting
Immediate visual refresh

The grid is bound directly to the collection of ExpenseLine entities belonging to the selected ExpenseSheet.

Expense Line Detail Dialog

[Insert screenshot here]

A dedicated popup dialog was generated for editing individual expense lines.

The dialog includes:

Expense Date
Expense Type
Description
VAT Rate
Amount
Payment Method
Receipt information

The dialog operates within the same DataContext as the parent ExpenseSheet, enabling all modifications to remain in memory until the user explicitly saves the expense sheet.

Step 4: Implementing Business Logic

Only a very small amount of custom code was required.

The primary customization consisted of implementing automatic recalculation of the Expense Sheet total amount whenever an expense line was created, modified, or removed.

The process is entirely client-side:

User edits an expense line.
The line dialog closes.
The total amount is recalculated in memory.
The form is refreshed immediately.
No database update occurs yet.
Changes are persisted only when the user saves the Expense Sheet.

This approach eliminates inconsistent states and closely matches the behavior expected by business users.

Conclusion

Starting from the database schema created in the previous article, the entire application was built using:

Two entities
Four business enumerations
Four generated views
A small amount of custom business logic

No DTOs, GraphQL schemas, REST controllers, repositories, service layers, React components, frontend state management, or API integrations were required.

The result demonstrates how a framework such as Jmix can dramatically reduce development effort while still producing a fully functional enterprise application built entirely on standard Java and Spring Boot technologies.

For applications centered around data management, workflows, administration, and business processes, this approach can significantly reduce development time, implementation complexity, and maintenance costs while preserving full extensibility for future enhancements.

Sunday, May 31, 2026