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.
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 (Form at the top)
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 (Table at the bottom)
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
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.
