By Asanka Abeysinghe, Chief Technology Evangelist, WSO2
Low-code platforms have become increasingly popular as a way to help businesses meet the ambitious deadlines for digitisation that have arisen as a result of the disruption of the past year. For skilled developers they save time by eliminating basic coding and allowing them to focus on more complex challenges, while delivering apps rapidly. For citizen developers, the simplicity of low-code accelerates their ability to build the apps their business unit requires.
Nevertheless, while low-code platforms may promise to do the heavy lifting for skilled coders and allow citizen developers to leapfrog a large part of the learning phase, their focus on simplicity often comes at a price when they don’t meet the rigorous requirements of enterprise application development.
To understand where the limitations arise, we can examine how low-code use typically plays out in an organisation, and look at an alternative approach that allows citizen developers to continue playing a key role in enterprise application development while also enhancing their technical awareness by making a closer connection between the visual interface and underlying code.
The business case for low-code platforms
Low-code platforms allow managers and business users to apply their detailed knowledge of their department and business processes to create their own apps, even though they may have limited knowledge of coding.
Low-code tools eliminate coding in most projects with a drag-and-drop interface. Because many tools come with pre-defined and pre-tested templates, creating applications with requirements that fit into the scope of these templates is straightforward. And you have a working application (or at least a prototype) in just a few minutes.
Instead of coding applications from scratch, these visual development platforms allow developers, with varying skills, to focus on business goals rather than the technology. This means reduced complexity, less effort, and increased developer productivity, which, in turn, means faster projects, increased satisfaction, and lower budgets for the C-suite.
The compelling business benefits have helped low-code tools move towards mainstream adoption. However, even though most low-code platforms allow users to add code for custom needs, this can become prohibitively complex in more sophisticated enterprise use cases. Getting a new app up and running in days is great – unless it doesn’t actually do what it is meant to.
It is here where low-code platforms suffer compared to the advanced environments and tools at the disposal of highly skilled developers.
The five key limitations of low-code platforms
Version control and teamworking: With visual-only development, it’s very difficult to have entire teams of software developers work on the same project, simultaneously, without encountering significant version control issues due to a lack of mechanisms to allow safe collaboration.
Testing, debugging and security: options are limited on most low-code platforms and visual workarounds often hide the inner workings. If something goes wrong with the app, even an experienced programmer can struggle to work out what is going on beneath the surface. The same can be true of security testing – without visibility into the underlying code, security scanning becomes more complex.
Tailoring: low-code platforms often only deliver limited customisation, which may fit the original application scope, but can fall short as requests for more sophisticated evolutions arise.
Integrating with enterprise applications: enterprise apps often need to also connect with distributed systems, archaic legacy applications, overly complex third-party APIs, commercial off-the-shelf systems, and much more. These integrations are not simple, involving complex data mappings, transformations, filtering, protocol conversions, etc. In such cases, coding is easier than graphical configuration because you can only visually model so much before it’s more efficient to drop into text.
Vendor lock-in: Many platforms are proprietary systems that either prohibit the underlying code from being moved out, or generate convoluted code that is neither readable nor reusable. This makes it difficult to move the resulting app to a different platform, thereby creating a risk of vendor lock-in.
How to leverage low-code effectively for enterprise applications
These limitations could make a strong case for avoiding low-code platforms and letting software engineers use a trusted programming language to build enterprise applications. But there is an approach to low-code that harnesses its potential to streamline enterprise application development.
The key is straightforward: supply “clean” code. In other words, the low-code platform lets developers switch between options. They can create apps using the visual flow representation, which generates app code, or drop down into the code to write the application, which simultaneously creates the visual flow. By providing a simple code representation for each app built via the low-code platform, users can have the best of both worlds.
To be effective, the code representation should:
- Be based on open standards
- Represent the low-code flow without any gaps
- Be able to run on any hardware/OS platform.
There are six main benefits of such a code representation:
- No limitations to customising and extending the application to fit the business.
- Developers can harness the power of sophisticated IDEs, libraries, and frameworks if to make enhancements that can’t be made via the UI.
- Teams can apply the tried-and-tested software development lifecycle (e.g., use a code repository, apply CI/CD), because one shouldn’t give up the discipline of software engineering for the sake of productivity or speed.
- Teams have the support they need for collaboration (e.g., code reviews via diffs).
- No proprietary lock-ins and no black box.
- The textual representation helps developers understand the underlying mapping between UI components and the code, helping to streamline development for custom needs.
Low-code is a powerful concept that can tremendously improve an organisation’s facility for sustainable and disruptive innovation.
However, low code is still early-stage and it may not prove viable in the long run because enhancements to applications are inevitable, and such customisations can get complicated due to platform limitations. So, platform vendors must continue to evolve low-code tools if they are to become truly viable for enterprise applications.
One solution is to make a textual representation of the graphical flow available to users as clean, readable code. The long-term benefits of being able to export that code and use it to follow the standard but proven software engineering process far outweigh anything low-code platforms have to offer. From there, low-code can live up to its promise to make complicated enterprise application development into something truly accessible and powerful.