The low-no-code series – AutoRabit: Clicks not code needs complexity control

The Computer Weekly Developer Network gets high-brow on low-code and no-code (LC/NC) technologies in an analysis series designed to uncover some of the nuances and particularities of this approach to software application development.

Looking at the core mechanics of the applications, suites, platforms and services in this space, we seek to understand not just how apps are being built this way, but also… what shape, form, function and status these apps exist as… and what the implications are for enterprise software built this way, once it exists in live production environments.

This post is written by Tim Van Ash, SVP Products and Technology at AutoRabit – a company known for its suite of products for DevOps for organizations to automate their CI/CD process for cloud-based development platforms.

Van Ash writes as follows…

The world of low-code no-code development has grown in popularity because it opens the world of software development up to everybody. Before ‘Clicks Not Code’ became a well-known phrase, developers had to learn entire languages to produce updates and applications.

The benefits of a low-code no-code environment are very attractive, but they are a bit of a mirage when we start looking to the future.

Instituting a DevOps mentality – along with automated DevOps tools – is a popular way to maximise returns from a development pipeline. Combining the efforts of development teams with operations teams streamlines many processes, reduces waste, and leads to strong products produced faster.

However, another byproduct of pushing your low-code no-code environment further is the increased complexity of the environment as a whole.

Inevitable growth in complexity

Low-code no-code doesn’t stay simple for long. The next stage for every low-code no-code environment will be closer to a traditional dev environment… and this brings along its own challenges.

Every customisation, function and linked object or field will result in metadata. The implications of an increased amount of metadata show themselves as challenges when managing changes. 

Teams grow. The expectations of a DevOps team expand. This inevitably comes together in the form of complex business practices, which are reflected in the complexity of the environment itself.

Metadata is everything

We mentioned how metadata plays a role in making a low-code no-code environment more complex.

Operating within a low-code no-code environment seems simple at first, but the introduction of new permissions, settings, or objects will create metadata. This pool of metadata continues to grow exponentially with each new setting, object, or field. The connections between these factors become more entangled, leading to wide-ranging and unforeseen effects from simple mistakes.

Understanding this inevitable growth in complexity can help DevOps teams control their environment from the start, instead of being surprised by the intricate webs of relationships when changes are introduced later on.

Maintenance challenges

Van Ash: Complexity matters really matter, make sure your DevOps delivery is deliciously divine & delectable.

The implications of increased complexity in low-code no-code developing go beyond the need for a deeper level of familiarity with dev environments. Speed and performance will also degrade over time.

The development org becomes larger – and with this increase in size comes complexity.

Technical debt builds up over time. Shortcuts only put issues off for another time. This will contribute to the overall complexity of your low-code no-code environment and will need to be addressed before it gets out of hand.

Eliminating out-of-date metadata and archiving unused data helps to manage technical debt. Reducing the amount of technical debt in your dev environment will reduce bugs and errors, improve the experience for the end user, and even help support data security.

Scalable solution insistence

The next phase for low-code no-code development environments is an increase in complexity. Many begin with a low-code no-code approach but need to pivot in order to keep up with emerging trends. The good news is there are numerous automated tools that can help DevOps teams grow along with their dev pipelines.

Static code analysis, CI/CD and data backups are essential aspects of properly supporting your DevOps team as their environment grows more complex.

The world of software development is anything but static. The most successful companies will be the ones that are able to keep up with emerging changes and adjust their approach – even if that means leaving low code/no code processes behind.

SearchCIO
SearchSecurity
SearchNetworking
SearchDataCenter
SearchDataManagement
Close