Streamlining User Task Interfaces with Custom Form Generation in BAMOE v9.2.1 and above

If you’ve ever built user tasks in a business automation project, you know how important it is to have clean, intuitive forms that guide users through the process. Whether it’s collecting candidate info during a hiring workflow or approving a request, custom forms make these interactions smoother and more tailored to the business context.

In previous versions, generating these forms in Business Automation Manager Open Editions (BAMOE) version 9 meant using a tech preview CLI tool—functional, but not exactly developer-friendly and not fully supported. BAMOE v8 created .frm files, which were only editable in Business Central. Now, things have gotten a lot easier. BAMOE has introduced a new way to generate custom forms right from the VS Code extension, making the whole experience faster and more integrated with your development workflow. These generated forms are either HTML or TSX files, fully editable within VS Code!

In this post, we’ll walk through how this new approach works, what you need to get started, and how you can use the generated forms in your BAMOE Quarkus or Spring Boot projects.

From CLI to VS Code: A Developer-Friendly Shift

Let’s be honest—CLI tools are great for automation, but they’re not always the most intuitive when you're deep in development mode. That was the case with BAMOE’s original form generation tool. It worked, but it required manual setup and wasn’t exactly integrated into your day-to-day workflow.

That’s changed with the BAMOE Developer Tools extension for Visual Studio Code. Now, instead of running scripts or remembering command-line arguments, you can generate custom forms with just a few clicks from the command palette. It’s a smoother experience that fits naturally into how most developers already work.

This shift isn’t just about convenience—it’s about making form generation more accessible, faster, and easier to maintain. Whether you're building a new process or tweaking an existing one, having this capability right inside VS Code saves time and reduces friction.

Prerequisites and Setup

Before you dive into generating custom forms, there are a few things you’ll need to have in place. The setup is straightforward but skipping any of these steps can trip you up later—especially during the form generation process.

Here’s your checklist:

• Java 17
• Apache Maven 3.9.6
• Visual Studio Code
• BAMOE Developer Tools extension
• A business service project built with Quarkus or Spring Boot

Once your project is set up, make sure to run a full Maven build using `mvn clean package` or `mvn install`. This step is crucial—it creates the target/classes/META-INF/json-schemas folder, which contains the schema files used to generate the forms. Just running `mvn compile` won’t cut it, since it doesn’t produce the necessary artifacts.

With everything in place, you’re ready to open VS Code and start generating forms with just a few clicks.

Generating Custom Forms

Once your project is set up and compiled, generating custom forms is surprisingly smooth. BAMOE’s VS Code extension adds a command called “BAMOE Developer Tools: Generate form code for User Tasks” to the command palette, and it walks you through the process step by step.

Here’s how it works:

1. Open the command palette (`Ctrl+Shift+P` or `Cmd+Shift+P` on Mac) and type “BAMOE” to filter the commands.

2. Select “BAMOE Developer Tools: Generate form code for User Tasks”.

3. Choose your project folder (usually the workspace root).

4. Pick a UI library—either Bootstrap for HTML forms or PatternFly for React-based TSX forms.

5. Select the user tasks you want to generate forms for.

6. Decide whether to generate forms for all tasks or just specific ones.

After running the command, you’ll find the generated files in a folder called custom-forms-dev under resources. Each form is tailored to the selected user task, and you’ll also get a config file that helps load the necessary styles and scripts. For example, Bootstrap forms will need jQuery and Bootstrap scripts, while PatternFly forms are self-contained and don’t require external assets.

You can even re-run the command to regenerate or override existing forms—handy if you’ve made changes to your process or want to switch UI libraries.

Using Custom Forms

Once your forms are generated, the next step is checking them in action. During development, it is possible to use BAMOE Quarkus Dev UI or BAMOE Spring Bot Web Console to visualize and edit your custom forms.

To make this work, just drop your generated forms into the src/main/resources/custom-forms-dev folder of your project. Once the Quarkus or Spring Boot dev server is running, you can access the UI at `localhost:8080`, navigate to the Forms tab, and preview or tweak your forms right there in the browser.

You’ll see both Bootstrap (HTML) and PatternFly (React) forms listed, depending on what you generated. You can click into each one, make changes, and see them reflected immediately. It’s a great way to fine-tune the user experience without needing to rebuild or redeploy.

When using the dev UI, the custom forms are loaded directly into the pages they are used. For example, by generating the required form to start up a process instance, the new custom form will be automatically loaded in the process instantiation page. The same will happen for User Tasks when opening a task.

One thing to note: this feature isn’t available in the BAMOE Management Console, so if you're working in that environment, you’ll need to integrate the forms manually into your own custom UI. The good news is, the generated forms are clean and modular, so plugging them into your app should be straightforward.

Conclusion

Custom forms are one of those features that quietly make a big difference in business automation projects. They help bridge the gap between process logic and user experience, making human tasks more intuitive and efficient.

With the move from CLI tooling to the BAMOE Developer Tools extension for VS Code, generating these forms has become a lot more accessible. Whether you're working with BAMOE Quarkus or Spring Boot, the new workflow lets you quickly spin up forms, customize them, and plug them into your UI with minimal hassle.

If you haven’t tried this out yet, it’s worth exploring. The tooling is flexible, the output is clean, and it fits naturally into modern Java development workflows. Plus, having support for both Bootstrap and PatternFly means you can choose the UI style that best fits your application.