Roadmap

Discover and vote on upcoming features

Upcoming

Import of OpenAPI spec

»Similar to the SQL import, an OpenAPI Specification could be imported in the Controllers tab. The would generate all the REST controllers defined in the specification, with all the features supported by Bootify.

Spring GraphQL option

»With a new option Spring for GraphQL can be added to your project. It will replace all RestControllers and CRUD endpoints with proper GraphQL schemas.

Kafka integration

»To further improve the generated prototype, an option for integrating Kafka should be available. This includes defining topics as well, where the application is either a producer or a consumer. If the option for integration tests is enabled, Kafka should be included via Testcontainers.

In Progress

Add feature package field

»With a new field at the entities, data enums and so on the code can be grouped into a specific target package.

Done

Include .gitattributes

»A basic version of this file helps working together with different operation systems.

Support classExtension snippets

»In an Enterprise template it should be possible to provie files within the classExtension directory to dynamically extend Java or Kotlin classes.

Offer Vite as a choice

»Currently, React and Node based frontend stacks are based on webpack. Vite is usually a better choice nowadays, so this option should be available and the default for new projects.

Provide Bootify MCP

»The MCP can be used in Claude Code or Codex, helping to prepare the basic project structure without using lots of tokens.

Add deployment option using GitLab

»Next to the Heroku deployment using GitHub actions, the same should be possible using GitLab pipelines.

Add column index option

»When defining or extending a database schema, single columns should have an index so that later queries are performant. With a new checkbox in Bootify this can be supported.

Add AGENTS.md and CLAUDE.md

»As programming with AI is now working on a decent level, every project should contain an AGENT.md and CLAUDE.md right from the start.

Playwright frontend testing

»If a frontend has been selected, Playwright should be available as a testing option. It'll open the frontend in a browser and provide high-level tests in a similar fashion to the REST API integration tests.

Unidirectional relations by default

»Relations should be created as unidirectional, unless the opposite direction is explicitly required. As a rule, dedicated queries in the repositories are preferable to implicit queries by Hibernate.

Heroku deployment

»Heroku is a comfortable and affordable provider for deploying Spring Boot apps. With a new option and documentation a Bootify project can be prepared for deployment using GitHub actions.

Add support for Java 25

»Java 25 is an LTS version and now available! As soon as all tools (like Gradle) support it, it can be added to Bootify as well.

Remove line breaks from README

»Typically paragraphs in the README are written inline on a single line, since line wrapping is handled automatically by the editor. The existing line breaks can be removed.

Spring Modulith support

»As another modularization option Spring Modulith should be selectable. It enables the Modules tab and creates a project structure according to its documentation.

Add jte as frontend option

»The Java Template Engine (jte) is a lightweight template engine for server side rendering. It should be available as an alternative to Thymeleaf.

Generate entities with empty collections

»Currently relation fields in JPA entites are null by default and must be initialized when required. With this change they always provide an empty collection, so when accessed the null check is not required anymore.

File type and upload

»With a new type “File” it should be possible to persist files in the database. With the CRUD option or as a custom controller, these can also be uploaded or downloaded via the frontend or REST API.

Advanced multi-module setup

»A new tab should be available for multi-module projects, allowing to define modules and their dependencies to each other. If possible, all other objects (entities, security configs, controllers) should be assignable to such modules, so the generated application already splits the code accordingly.

Add social login options

»The Spring Security setup should provide a way to add one or more social login. A user can then authenticate with an existing account (like Google, GitHub, LinkedIn).

Add React as frontend option

»With React another SPA option for the frontend can be provided.

Provide password reset function

»A forgotten password flow can be activated for the form-based login or JWT. The fields of the user table in which a unique ID and a start date are stored should be selected for this. A service for sending mails must be integrated as well.

Customizable date fields

»Currently the date fields of entities are always called dateCreated and lastUpdated. These names should be adjustable in the Professional plan. In the DevOps plan they can be defined globally for each template.

Mail service configuration

»In preparation for the password reset function, a mail service must first be configurable. This should be able to send HTML emails via SMTP that have been rendered using Thymeleaf.

Fixed frontend versions

»Currently, the library versions in the frontend start with ^ or ~, so Node automatically uses higher major or minor versions if they are available. Occasionally this leads to unexpected errors in applications that were previously tested successfully. For this reason, all frontend versions should use fixed versions, and updates are performed only manually and in a controlled manner.

CRUD options during SQL import

»When importing an existing schema, it can save some manual work if you can preselect the default CRUD options for the new entities.

Support refresh token with JWT

»Additionally to the JWT a refresh token should be provided, stored in a selectable field in the user table. The Angular client can use the refresh token to get a fresh JWT.

Add changelog breakpoints

»Typically, the database schema grows over time as requirements evolve. With this feature, a developer can add breakpoints to a project. All modifications to the database schema after the breakpoint are written into a new Liquibase changelog / Flyway migration script, so it can be copied and used onto an existing codebase.

Improved dependency configuration

»In the DevOps plan, the configuration of custom dependencies should be improved to allow their inclusion as api, implementation, development or test.

Remember-me dropdown

»The form-based login can be enhanced with a dropdown for supporting remember-me cookies: they can either be fully disabled, always active or active when the user enabled a checkbox.

Add Git integration

»It should be possible to export the project to a specific branch of a GitHub, GitLab or Bitbucket repository. This simplifies the update to new Spring versions and keeping track of other code changes.

Multiple security configations

»Instead of allowing only a single security type, multiple configurations should be configurable. For each config the roles can be defined together with the paths of the application they are allowed to access. If multiple configs connect to the same table and fields, they should share the UserDetailsService.

Spring Session support

»Add a dropdown for configuring Spring Session with Redis or the currently configured database.

Support list and map types at entities

»List and map types should be selectable as a field type for entities. Although not all databases support them natively, they can be enabled with the proper library as JSON.

Add TypeScript option for Webpack

»Currently the Webpack-based Frontend option can be extended with custom JavaScript code. With a new option it can be changed to TypeScript, all compiled to minified JavaScript during build.

Add Angular as a frontend option

»For certain web apps, it is a better idea to use Angular instead of Thymeleaf. This should be available as an additional option for the frontend.

Keycloak Resource Server

»Currently the Keycloak option covers Keycloak integration as a client. With a new option your Spring Boot application can act as a Resource Server. This makes particular sense if the application has an Angular frontend.

Domain driven with technical subpackages

»Currently there is the choice between a technical or domain driven package structure. A third option can be added, splitting up the packages by domain, but further dividing them by technical subpackages (service, model, ...).

Database naming schema

»More database naming schemas should be selectable, giving the option to follow corporate naming conventions.

Improve pluralization

»At the moment, the plural is formed by appending an 's'. By using a suitable library, the generated code is more readable and usable.

Option for mapped superclass

»Any entity can be marked as a @MappedSuperclass and is then available for inheritence by all other entities, taking over their properties without beeing a table themself. For Mongodb they are just an abstract class.

Support Actuator configuration

»Spring Boot Actuator is a useful library for running an application in production. This can be supported with an additional option and basic configuration options.

Spring HATEOAS option

»Add an option to enable Spring HATEOAS for the endpoints, linking resources to each other.

Docker Compose option

»A new option adds the spring-boot-docker-compose dependency as well as a preconfigured docker-compose.yml, so the devlopment environment is available at once.

Spring Security with Keycloak

»Add the option to protect your application with Keycloak, including integration tests / Testcontainers support.

Allow unidirectional relationships

»In certain use cases you may want to have an unidirectional relationship between two entities, so navigation is limited to one side. This option should be available for all types except Many-to-many.

Provide frontend datepicker

»When the frontend contains a form with a date type, a datepicker should be available to make the user experience more convinient.

Provide section for working with the code

»Developers often have similar questions when extending the generated code. A new section 'Next Steps' will give practical tipps and explainations when starting the development.

Enrich frontend with htmx

»Htmx is a smart, minimalistic frontend library to improve backend integration by simple HTML attributes - without the need to write JavaScript as a developer. With a new checkbox this could already be prepared by Bootify.

Add CRUD search filter

»When you have large datasets, you need better tools for finding a searched entry. A new search filter for the CRUD frontend and REST API would help out here – in a first, simple version only the ID field would be searched.

Use WebJar for direct Bootstrap integration

»When using the frontend-stack with direct integration of Bootstrap, currently the JavaScript and CSS libraries are loaded from a CDN. While this gives a speed advantage, in many cases it's desirable to make the application available without internet access. By switching to WebJar, the frontend libraries can be provided internally with a Maven dependency.

Custom modules for multi module option

»If multi module is enabled for a project, it should be possible to add custom modules via a text field. They are empty by default, but the structure and setup is already prepared.

Provide Readme.md

»With the new frontend options, a readme on how to start development would make life easier.

Spring Security with form based login

»JWT is a good choice for a REST API, however a Spring MVC frontend or a mixed app can be protected with a classical form based login.

CRUD frontend generation

»Generate a simple frontend for selected entities, allowing CRUD operations (list, create, update, delete) in the browser. First version is based on Thymeleaf with a basic styling and could be used for an admin backend as well.

Query parameters for custom endpoints

»Sometimes it makes sense to access a REST API with query parameters. This can be for example a custom filter or a search, where no fixed resource is returned. Query parameters should be supported for the custom endpoints of the Professional plan.

Add RegistrationController to JWT

»Currently the JWT Security Feature comes without a RegistrationController, because it may look different depending on the project requirements. However Bootify can still provide an option to add a registration endpoint, which doesn't require authentication and does a proper password hashing.

Support MongoDB

»Add support for MongoDB as a document-oriented database. The schema migration should be done with Mongock, as this is the most mature solution at the moment.

Application.properties option

»Many developers prefer application.properties over application.yml. This should be selectable with an option.

Support MapStruct for DTO mapping

»Currently the mapping from a JPA entity to a DTO is done in the service class manually. While this gives a lot of flexibility, with the new option for MapStruct the code is getting shorter and more descriptive.

Upgrade to Java 17

»As Java 17 is officially released and also a Long-Term-Support (LTS) Version, this should be the third option next to Java 8 and 11.

Pagination option

»Add an option for pagination to the generated REST API. Provide a minimal Page class for the response which reflects the current pagination information.

Support MariaDB

»Add MariaDB to the list of supported Databases.

Include Kotlin

»Add a possibility to select between Java or Kotlin as the preferred programming language. Use the Kotlin DSL in case of a Gradle build and hide the Lombok option for Kotlin projects.

Separate service and service interface

»The services generated for the CRUD controllers should have a separated interface and a service implementing it. This can be configurable with a dedicated option.

Domain-driven packages

»Add an option for organizing the classes in a more domain-driven way, organizing the classes around the entity.

Use ResponseEntity at controllers

»Most developers prefer to use the ResponseEntity class in RestController methods, keeping the body and HTTP status together.

Add Many-to-many relation type

»In most cases it's preferable to create an intermediate table together with two Many-to-one relations, as this gives more flexibility in the long run. However a Many-to-many relation can be useful for simple assignments with a composite primary key.

Spring Security with JWT

»Add support for protecting the REST API with JWT, backed by Spring Security. Users can be loaded from the database.

Add integration tests

»Generate IT tests based on the controllers of the project (CRUD as well as custom controllers). A containerized instance of the database can be used based on Testcontainers.

Submit missing feature

Are you missing a particular feature? Let us know!

Name

Description

E-Mail

Create new account

Log in with existing account

Reset your password