Release Management in the Low Code World
No Code and Low Code platforms are great tools for speeding up the development process. They empower departmental users to build software without having to wait for scarce IT and development resources to become available.
However, these technologies are no silver bullet for making every project a success. Specifically, issues around collaboration, version management, automated testing, and deployment are frequently cited as problems that haunt not only classical development projects, but also plague the rising no code / low code movement.
In this article, we describe the problems in more detail and show how some of the traditional tools and processes can help to remedy the situation without loosing the no code / low code agility.
Managing Development and Production Environments
Once the first version of a product is released, the product team usually starts thinking about adding new features or fixing bugs in the current version. If the system performs write operations on databases, calls services with side effects, or has to be concerned about introducing load on production systems, the development team has to work in a sandbox environment that uses development databases and services. This article on Salesforce release strategy describes how content “usually moves across multiple environments until it is finally deployed in production” in the context of Salesforce Low Code applications.
The solution to this challenge is to make it as easy as possible for team members to get access to a sandbox instance that can be configured with development resources. In the Dashjoin Low Code platform, this is achieved by simply parameterizing a Docker container that serves the sandbox environment either on a developer’s computer or a cloud based instance.
Version Control
Compared to classical software, low code projects will be more concise with respect to lines of code. No code platforms typically contain small code fragments and software configurations such as forms or backend mappings. From a version control perspective, it makes no difference how you express application logic, and issues around versioning are frequently mentioned in the No Code / Low Code worlds.
The Mendix Guide to Low Code Development lists version management as one of the key aspects to consider when choosing a Low Code platform. Another issue is how multiple developers collaborate on a project. The Salesforce paper mentioned above mentions that “it is not uncommon to have frequent changes or even accidental overwrites to your orgs”.
Obviously, the solution to this challenge is to introduce version control in one form or the other. Mendix, for instance, allows for versioning, branching, tagging, etc. in the Mendix Team Server. At Dashjoin, we believe that off the shelf solutions like GIT / GitHub are better suited for this task. Any code fragment or project configuration is serialized in JSON files, and thus, can be placed under version control easily. The platform can be configured to pull a project upon startup, making it very easy to transport an app from development to production.
Obviously, version control must be optional for small projects with only one or two developers. It is a must for large projects, no matter whether No Code, Low Code, or traditional coding is used.
Automated Testing
In order to ensure a high quality, software testing is a must. Automated testing requires some initial investment, but it certainly pays off in the long run. A 2022 IEEE empirical Study of Developer Discussions on Low-Code Software Development Challenges found that “low-code developers face challenges with automated testing.”
Obviously, end to end testing frameworks like Cypress or Selenium are applicable to any kind of web-based application, regardless of the technology that was used to build it.
However, we believe that it is important for the No Code / Low Code platform to offer built-in support for unit testing. Mendix, Appian, and other vendors offer this feature. The Dashjoin platform relies heavily on JSONata expressions that are embedded in page layouts and platform functions. These expressions can be unit tested by providing inputs and desired outputs.
Deployment Governance & Control
Agility, the blessing of No Code / Low Code, can also be its biggest problem. This InformationWeek article looks at 4 common reasons Low-Code projects fail. It lists “not dealing with deployment and maintenance” and “focusing on building the application and not considering how to deliver it” as two of these. This Harvard Business Review article states that “broad use of these tools institutionalizes the shadow IT phenomenon, which has bedeviled IT organizations for decades — and could make the problem much worse, if not governed properly.”
In our view, governance and control is tightly coupled to version management and documentation. The article states that a developer “may leave the company, and no one knows how to change or support the system they developed”, a problem that can be addressed by documenting changes in the source code management system.
Defining a proper release process is also critical in avoiding these problems. We recommend tagging a released version in GIT, and instructing the production instances to use the tagged version of the app. This allows development to proceed safely without impacting production.
Summary
In this article, we have shown that Low Code / No Code projects — while benefiting greatly from concise application logic and reduced development times — are much like classical software projects after all, despite using a different development technology. We think that a best of breed approach that combines Low Code technology with “classical” tooling and approaches for unit testing and version control can successfully address these challenges. For more details on how this approach is realized in the Dashjoin platform, please check out the project page as well as the video below.
