Introduction
AppJars is a suite of full-stack functional modules for Java enterprise applications built on Spring Boot and Vaadin. Each module — called an AppJar — delivers a complete, production-ready feature as a drop-in dependency: from user authentication and role management, to AI-powered chat assistants, issue tracking, internationalisation, email delivery, and more.
The core idea is straightforward: recurring enterprise requirements should not be re-implemented for every new application. AppJars encapsulate the analysis, design, implementation, testing, and maintenance of these features so that development effort can be concentrated on what makes each application unique.
Building Enterprise Applications with AppJars
Modern enterprise applications share a common infrastructure layer — authentication, configuration, notifications, audit trails, scheduling, localisation — that typically accounts for a large portion of initial development time and ongoing maintenance. AppJars address this layer as a set of composable building blocks.
Consider a complete enterprise application assembled from AppJars: User Manager handles authentication, role-based access control, and self-registration; User Profile extends each user record with custom profile data and avatars; Dynamic Menu drives navigation from the database so that menu structure and visibility are configurable at runtime without a redeploy; Configuration Manager externalises application settings into a live-editable store; Activity Log captures a full audit trail with configurable extraction and retention policies; I18N Manager backs all UI labels from a database-driven translation store; Email Manager handles outbound email queuing and delivery tracking; Process Manager schedules and monitors background tasks; Issue Tracker provides a complete project and issue management system; Data Query publishes stored queries as reports and dashboards that administrators define at runtime; and AI Support adds an LLM-backed assistant grounded in the application's own knowledge base.
None of these modules requires the others to be present. Each can be adopted independently and incrementally, so an application can start with just User Manager and grow to incorporate additional AppJars as requirements evolve. Optional integration bridges between modules — documented in each AppJar's Getting Started guide — allow them to share context when they coexist.
Available AppJars
| AppJar | Description |
|---|---|
| Activity Log | Records user activity events, with configurable extraction rules and automatic retention management |
| AI Support | Provides an LLM-backed assistant with RAG document knowledge base, streaming chat, and WhatsApp integration |
| Configuration Manager | Manages application-level and per-user configuration values at runtime, with live propagation to Spring properties |
| Data Query | Publishes stored SQL, HQL and REST queries as parameterised reports, charts and dashboards defined at runtime |
| Dynamic Menu | Manages application navigation menus from the database with role-based visibility and drag-and-drop ordering |
| Email Manager | Composes, queues, and tracks outbound email delivery with attachment support and background sending |
| I18N Manager | Manages translations and languages at runtime through a database-backed Vaadin i18n provider |
| Issue Tracker | Full project and issue management system with workflows, custom fields, time tracking, and role-based permissions |
| Process Manager | Schedules and monitors background tasks using cron expressions, with execution history and manual triggering |
| User Manager | Manages users, roles, groups, access rules, and authentication including Remember Me and registration links |
| User Profile | Stores extended profile information and avatar images for authenticated users |
Common Features
The following characteristics apply across all AppJars:
Pluggability — Integration is designed to require minimal configuration. Most AppJars require only adding Maven dependencies and registering a router layout. Spring Boot auto-configuration handles entity scanning, component registration, and startup logic automatically.
Layer independence — Each AppJar is split into contract modules (interfaces only) and implementation modules. An application that needs to call a service method can depend solely on the business API module, with no transitive dependency on JPA entities, Hibernate, or Vaadin. This supports clean architecture patterns and strict layer boundaries.
Customisability — Every layer exposes extension points. The data access layer can be extended with custom repositories to work with additional fields. The service layer supports custom logic through overriding service beans with a @Primary implementation. Application views can navigate directly to AppJar views as part of the application's own navigation flows. See Customization for techniques and examples.
Independence — AppJars do not depend on each other at the module level. They can be used in any combination. When multiple AppJars are used together, optional integration patterns are documented in each Getting Started guide (for example, wiring User Manager's UserService into AI Support's AuthenticatedUserProvider).
Internationalisation — All AppJars support translation via Vaadin's i18n mechanism. Built-in labels are defined with translation keys that can be overridden by adding messages.properties files to the application. When I18N Manager is integrated, all labels are resolved from the database automatically.
Licensing
AppJars are available in two modes: a free mode that can be used without a license, and a licensed mode that unlocks full functionality. In free mode, certain AppJars enforce limits on the number of records or operations to allow evaluation and small-scale use.
See the Licensing page for the full limits per AppJar and instructions on how to install a license.