Enhance your Salesforce development lifecycle with Flxbl (“DX@Scale”) and Hutte

Combining an open-source application lifecycle management (ALM) toolkit – Flxbl (formerly “DX@Scale”) – with the user-friendly UI of Hutte can reshape ALM in the Salesforce ecosystem.

This article showcases how modern DevOps practices are leveraged to streamline processes and benefit Salesforce Developers, Admins, and QA professionals by integrating these two cutting-edge tools.

For starters, let’s find out what Flxbl is.

What is Flxbl?

Flxbl enhances the effectiveness of the Salesforce "Well-Architected Framework" by offering a tailored roadmap for implementation, curated explicitly for Salesforce development teams. While the framework outlines fundamental principles and best practices for constructing resilient, streamlined, and secure Salesforce solutions, Flxbl equips teams with the required tools and methodologies to translate these principles into action.

This platform acts as a bridge between theoretical guidelines and practical implementation, empowering teams to understand and master the essentials of a well-architected Salesforce solution. It provides them with the necessary resources to achieve it through streamlined DevOps practices and collaborative workflows.

In other words, it provides the processes and tools to handle the ALM of Salesforce programs, such as:

• Org management
• Release management/CICD automations
• The collection of best practices around Salesforce with an emphasis on modular architecture.

Flxbl's main tool

Flxbl's primary tool is called "sfp." It's a CLI that abstracts the end-user from all the complex and tricky operations behind the above-mentioned points, making following them simpler. The "sfp" tool, all the documentation, GitHub Actions, and any other artifacts are open-source. Therefore, the community can freely use it and contribute to it.

However, it's important to note that this collection of processes, best practices, and tools does not mean implementing Flxbl includes all these elements. Instead, it's an incremental process.

Why use Hutte with Flxbl?

Watch our demo🎞️

While Hutte is an excellent tool for many stages of the ALM process (such as building and tracking changes with a simple UI), Hutte does not provide a fixed tool or strategy for handling the entire ALM process, such as release management tools and the strategy or processes to take the changes deployed up to production.

Instead, Hutte was created to allow our customers to have absolute control and flexibility over release management and other parts of the ALM process.

Hutte provides a superior product for:

• Scratch org and sandbox org management
• Org pools
• Changes retrieval and tracking.

On the other hand, Flxbl provides a great tool and practices for the release management side of ALM. However, not all members of a team will have the skills (such as Git and SFDX CLI skills) to work with Flxbl, therefore requiring a UI like Hutte for org management, changes tracking, etc.

Connecting and pairing Hutte and Flxbl is a match made in heaven, as both follow modern DevOps practices and have been designed and created in a way that completely aligns.

For Flxbl users, this is exciting news as Hutte has a UI that removes the most challenging part of the process for Developers – change and org management. Using Hutte, Flxbl projects are not a challenge for non-Developers, such as Admin and QA roles that may not be used to Git tooling and the use of the terminal.

Where to start when integrating Hutte and Flxbl

There are two scenarios:

1. A Hutte team looking for an enterprise, scalable ALM framework
2. A Flxbl team looking for a tool that enables Admins and low-code engineers to easily contribute.

No matter the scenario, both require the first step, which is to include the necessary changes in the Git repository.

Hutte’s recipe is here to help

While the integration may seem complex, Hutte is here to support you! We've created a comprehensive recipe with a baseline implementation combining Hutte and Flxbl.

Give it a try