Without observability, no-code cannot be scaled up!

What is observability?

According to Gartner, observability is “the development of supervision into a process, with a view to providing an overview of digital business applications, accelerating innovation, and improving the customer experience”.

More precisely, the observability of a system involves being able to identify undesirable behaviours, such as: the unavailability of the service, errors, sluggishness... it’s about knowing the system’s behaviour at all times, detecting the slightest anomaly, but also being able to understand why this anomaly is occurring, and ideally before it impacts customers, so as to be able to react rapidly and resolve it as quickly as possible.

Source : datadog (Observability Tools but for code apps)

Observability relies on the collection of three types of data: detailed event logs, granular information on the use of resources, and application traces.

An example of observability in no-code: if a field in Airtable is deleted when it is being used in an automation in Make, observability enables the fact that an error will occur to be detected prior to the launch of the Make scenario.

In order that it can be exploited correctly, this data collection must be of suitable quality and must be coherent, however, this alone will not necessarily be sufficient: it is also important to understand the correlation between the data collected, and the context in which it occurs. Implementing effective observability is no simple task: lack or excess of information, data distributed in silos, lack of correlation or manual correlation – there are many potential obstacles.

Within increasingly complex and interconnected environments, observability is able to detect weak signals. Coupled with artificial intelligence algorithms, one can identify scenarios that may cause incidents, so as to then discover the source. It allows you to increase your control over your system.

Finally, the key to success is the capacity to rapidly deploy this data. To do so, you will ideally have uniform access to all the data, as well as the ability to filter it, aggregate it, and visualise it in a relevant manner, so as to implement the necessary corrective actions more quickly and more efficiently.

Improvement of performance

While observability allows you to react effectively in emergency situations, this visualisation can also be used to improve the general performance of the system. Detecting instances of very high resource consumption (CPU, data volume…), implementing improvement processes, being able to predict future requirements so as to sustain the growth of your platform – there are many advantages.

At a time when digital transformation is accelerating, observability has now become necessary in order to achieve and maintain agility, speed, and performance, with a view to meet users’ ever-rising expectations.

Observability in no-code

State of play

Some no-code tools already offer monitoring and alert functionality (see table below). Monitoring is limited to simply displaying when an anomaly occurs, whereas observability allows you to understand the cause of this anomaly.

Nowadays the majority of tools interconnect with one another, so as to offer a complete stack, covering all expected functionalities -  this is what gives them their development capacity. However, this interconnection between tools generates significant complexity: a minor change in the name of a field in a database can have knock-on effects on an entire application. The fragmented views available in each of the tools are not sufficient to enable effective observability.





Comparison of a number of tools regarding their level of observability:

Often, the performance of these tools is not yet at the desired level, however, progress is being made. Make (formerly Integromat), for example, when changing its name and version, integrated into its API the ability to recover scenario logs, thus enabling the (automatic) monitoring of automations. Previously, the necessary provisions had to be implemented in order to address this flaw.

At present, this essentially involves adopting a proper system of documentation and good working practices, to ensure that you correctly grasp the implications of each change. In particular, you must ensure that transverse process mapping and data exchange between the tools are taking place. This involves a high level of manual labour and requires a great deal of discipline in terms of keeping the system up to date. We have now compiled a list of good documentation practices, however, these are far from ideal on account of their complexity of application.

You will have gathered that we are still a long way from achieving the goal of observability – at best, what we currently have amounts to supervision/monitoring.

Why must the observability of no-code be improved?

In order to be capable of managing a growing influx of users, to understand the use of resources, and to offer high quality and a competitive level of service: these are the essential elements if we are to scale things up.

There is still a way to go in order to bring no-code environments to the desired level of robustness. In addition to observability, the management of production and test environments, version control, release management, and many other aspects must as yet be improved.

With no-code editors having raised more than 4 billion dollars globally in 2021, it is safe to say that this field is progressing rapidly. We will be making our own contribution, with ncScale, through our Monitoring solution.


Credit: Photo by Luke Chesser on Unsplash

‍