Can You Build Complex Applications with Low-Code Tools?

TL;DR: To build complex applications with low-code tools without compromise, good platforms must have the right architecture from the outset. Otherwise, the complexity of the use case adds up with the complexity of the tools and their internal implementation into one big problem.

Low-code platforms and tools have become increasingly popular in recent years, as they promise quick first results, high agility in developing individual software solutions and a high degree of automation – exactly what is needed for the digital transformation, which is still progressing slowly in many organisations and sectors. However, a fundamental problem becomes apparent here, and it grows the more a development environment or platform is optimised towards no-code.

What do “low-code”, “no-code” and “pro-code” actually mean?

These terms describe tools and environments for creating and deploying software, from individual components up to comprehensive software solutions, that are built without (“no-code”), with only a little (“low-code”) or with predominantly hand-written program code (“pro-code”).

They promise to speed up the software development process and to increase productivity by eliminating programming effort. No-code tools typically focus on workflows that map business processes, so that typical applications of rather low complexity can be delivered quickly.

Put simply, no-code platforms offer their users a limited selection of prefabricated building blocks that only need to be configured and connected in order to efficiently define, for example, the user interface, the behaviour and the processes, as well as the interfaces for integration with other systems. The basic rule is: the easier a no-code tool is to use, the fewer configuration and combination options it offers. It follows directly that either the range of solutions that can be built, or their complexity and depth, is limited.

Low-code development allows scripting for more flexibility

Usually less convenient to use, but more flexible and therefore better suited for more complex use cases, are low-code platforms and tools that generally allow you to add your own markup or code, e.g. HTML, CSS and JavaScript in the frontend, or Java, JavaScript, Python, PHP, Ruby or R in the backend, for further customisation. This naturally requires some programming skills, but in return you gain extensive freedom in developing your software.

How it works and what limits it

In general, low-code and no-code frameworks work on the principle that various building blocks with a predefined range of functions are prepared as templates for developing applications. The exact function results from the parameters chosen by the developers.

You can think of this parameterisation as setting the switches (no-code) or programming the signal boxes (low-code) in a complex network of railway tracks. The more individual destinations and routes a train can reach on it, the more tracks and switches or signal boxes have to exist. Applied to software, this means that a high degree of customisation, which is important for innovative applications, comes with high system complexity, because all components have to be developed in advance and, above all, tested in every combination.

High degree of customisation and complex use cases

Programming, on the other hand – writing and compiling code by hand – can be thought of as building direct connections between any starting point and any destination, which is of course more laborious, but offers maximum flexibility and speed.

With low-code and especially no-code platforms, the limiting factor is the number and depth of abstractions. Abstraction here means separating the actual functionality into model and parameters. The more complex the model, i.e. the more functional building blocks and user-defined parameters it provides for managing an application, the more precisely specific requirements can be implemented. But each abstraction usually also brings its own technical layer, which makes the entire stack of the low-code or no-code platform more complex.

Since all parameters can be changed at any time to influence the appearance and behaviour of the low-code or no-code application, they have to be kept in a database and retrieved at runtime with every request, so that the possible paths provided in the model are selected and executed correctly for each request according to the persisted data.

While storing is uncritical, because it happens rarely compared to queries, retrieving the models and parameters places ever higher demands on the systems the more complex a use case is. The overall complexity is determined by the number of customisation parameters and by the complexity of the use case itself.

Factors that lead to high overall complexity:

• Individuality of the user interface (many custom visual elements, special input forms and displays)
• Number of data types and the dependencies/relationships between them
• Complexity of the behaviour / number of possible processes
• Number and complexity of the interfaces (internal and to external systems)

How high complexity affects performance

It is no surprise that the effort of using low-code tools to build individual, scalable solutions, and complex applications in particular, increases sharply with the complexity of the requirements.

The way the models and parameters that define the data and processes are persisted plays a major role here. The better a tool is suited to storing and processing complex data, e.g. by using a graph database, the higher the performance – not only of the platform and the tools themselves, but also of the applications built with them.

Conclusion

The more individual a software application is, and the more complex the data models and business processes it is meant to represent, the higher the internal effort for low-code tools, and especially for no-code platforms, to store and process the data required. In particular, the computing effort of generating appealing graphical user interfaces, user-friendly on mobile devices as well, quickly and easily, and of automating the deployment process, is extremely demanding.

Tools that are optimised for the low-code development of complex applications are ideal for this. Combined with powerful, scalable hardware, they play to their strengths and allow applications to be built quickly.

Ideal low-code tools for complex use cases must be optimised for them

Ideal low-code platforms are optimised for complexity by their very architecture and are aimed at professional developers. They offer prefabricated components and a range of tools and functions that make it possible, in the best sense of rapid application development, to use low-code to build new applications, but also mobile apps for existing applications. They are optimised for building applications by allowing them to be created with minimal programming effort.

In addition, good low-code platforms also offer no-code tools that make certain development steps possible without writing any code at all, e.g. creating the schema. Mobile application development is supported as well, and for selected use cases artificial intelligence can also be applied in a targeted way. Companies already have to think today about how they use AI to build applications.

Building applications quickly to increase productivity

Good systems run smoothly in the cloud and support various platforms when deploying applications. Low-code not only offers the advantage of building applications without writing much code, but also that companies can create and adapt their own application at any time, drawing on prefabricated components.

Above all, low-code helps to automate business processes. A good platform offers not only the possibility of building simple apps, but of creating extensive, complex solutions that meet all current and as many future requirements as possible. A good low-code platform therefore has a significance that goes beyond simply “using low-code”.

Ultimately, however, it matters less whether a platform leans towards low-code or no-code. Ideally, the platform supports every step relevant to developing applications of realistic complexity, and offers developers tools that are each optimised for the task at hand, from no-code through low-code to pro-code.