Low-Code Platform

Under the heading of ‘low-code’, a new class of software development environments has emerged in recent years which is not only said to afford the prospect of a substantial increase in software development productivity, but also to yield new ways of promoting business IT alignment and user empowerment. These platforms now go by the names of low-code platform (LCP), low-code application platform (LCAP), and low-code development platform (LCDP).

Presumably coined by a market research company in 2014 (Forrester) (Richardson and Rymer 2014), several indicators suggest that a major trend has by now evolved around the label ‘low-code’. Large software vendors, including IBM, Microsoft, and Oracle, have begun to incorporate low-code solutions into their product portfolios. Market research companies have forecast a considerable market potential for LCPs (e.g., Rymer and Koplowitz 2019; Vincent et al. 2020). These assessments, together with the promises of vendors, have attracted the interest of corporate investors (Shah 2020). For example, Siemens recently bought a leading LCP vendor, reportedly at a significant price.¹ Moreover, the discussion and presentation of LCPs thrives on, and itself perpetuates, the trends surrounding other current buzzwords such as ‘citizen developer’, ‘robotic process automation’ (RPA), ‘user experience’, and ‘microservices’.

Unfortunately, the rise in attention has not been paralleled by similar advances in the conceptualization of LCPs. For initial reference and for later comparison we cite, at this stage, a definition proposed by a market research firm:

“An LCAP is an application platform that supports rapid application development, deployment, execution and management using declarative, high-level programming abstractions such as model-driven and metadata-based programming languages, and one-step deployments. LCAPs provide and support user interfaces (Uls), business processes and data services.” (Vincent et al. 2020, p. 1)

An analysis of this tentative characterization of LCPs suggests two conclusions. First, LCPs are intended to help achieve objectives which have been at the core of business information systems research for a long time. Among these are increasing productivity and reducing costs of developing and maintaining enterprise software systems, improving organizations’ ability to adapt software systems to rapidly changing requirements, and empowering users. Second, however, it is not at all clear what distinguishes LCPs from existing software development facilities, such as classical integrated development environments (IDEs) and tools for model-driven development (MDD). Taken together, the low-code trend presents itself as a contribution to goals at the heart of business information systems research, but is in dire need of clarification.

With this in mind, the goal of this paper is to give a balanced account of the current trend of low-code development, and to place the topic in the broader context of business information systems research. Specifically, we address three questions:

The paper is structured as follows. We begin with a brief survey of the reception of the low-code trend in practice and academia (Sect. 2). Subsequently, we present an answer to the first question, drawing on a detailed study of ours of selected LCPs available on the current market (Sect. 3). The study was decidedly exploratory and, given the limited number of systems considered, cannot claim to be representative, but the obtained results nonetheless throw light on the characteristic features of a variety of LCPs. Thereafter, we turn to the second question, formulating several general findings and contrasting them with existing approaches from research on software development productivity (Sect. 4). These findings, in turn, provide the basis for examining the third question, leading us to suggest a variety of attractive research opportunities for the field of business information systems (Sect. 5).

The trend surrounding low-code development is carried by an appealing story. It is widely known that the lack of professional software developers is a major obstacle for many companies in successfully dealing with the digital transformation. Moreover, there is the perennial problem that software development projects often suffer from poor efficiency, or fail altogether. Portrayals of LCPs by vendors and market research firm tie in with these problems and promise relief:

“When you can visually create new business applications with minimal hand-coding – when your developers can do more of greater value, faster – that’s low-code.”²

“That’s where the power of citizen development comes in – with no-code/low-code platforms, anyone can build applications without software expertise, significantly faster, and at a fraction of the cost.”³

“Enterprise low-code application platforms deliver high-productivity and multifunction capabilities across central, departmental and citizen IT functions.” (Vincent et al. 2020, p. 1).

The enthusiasm and hopes engendered by claims such as these are further nurtured by reports of successful applications of low-code solutions in industry (e.g., Shah 2020), and by optimistic assessments of the future economic potential of the low-code sector. For example, Gartner has predicted that by "2023, over 50% of medium to large enterprises will have adopted an LCAP as one of their strategic application platforms" (Vincent et al. 2020, p. 1).

It was only after some years that academic investigators took notice of this trend (e.g., Henriques et al. 2018; Zolotas et al. 2018). But now there is growing awareness of low-code in the research community. For example, the workshop on low-code development at the Models conference in 2020 attracted the highest number of submissions of all workshops.⁴

Regrettably, much work on low-code development to date has assumed a relatively uncritical attitude, and all too little effort has been spent on developing a clear and distinct concept of these systems. For example, one author has defined LCPs thus: “The low-code platform is a set of tools for programmers and non-programmers. It enables quick generation and delivery of business applications with minimum effort to write in a coding language and requires the least possible effort for the installation and configuration of environments, and training and implementation” (Waszkowski 2019, p. 376). The favorable, even euphoric, tone and the conceptual ambiguity of this statement are characteristic of many descriptions found in the field (cf., e.g., Chang and Ko 2017; Ihirwe et al. 2020; Sanchis et al. 2020). That said, a modicum of work towards a more nuanced view of low-code development is scattered in the literature. For example, Sahay et al. (2020) have conducted a study of eight LCPs with the aim of clarifying and comparing the functionalities of these systems. Moreover, there are a few critical voices that question the supposed novelty of low-code environments. The most notable example is Cabot (2020); we will return to a verdict of his later on.

This brief outline of the reception of low-code in practice and in academia indicates a propensity toward marketing jargon, terminological inexactitude, and inflated promises. Meanwhile, profit and non-profit organizations face the question of whether, and under what conditions, investments into low-code development projects are justified. The need to support these decisions is a further reason for business information systems research to analyze the subject and to contribute to a clarification of the term.

In want of informative and consistent descriptions of LCPs, the only way to obtain a concept or even an idea of LCPs is an analysis of the actual platforms offered under this label on the current market. If these platforms have common features, it may become possible to derive inductively from them a possible conceptualization of low-code development. With this aim in mind, we conducted an explorative study of ten LCPs, which has been published separately (for a synopsis with a technical focus, see Bock and Frank 2021; for the full study, see Frank et al. 2021). The purpose of this section is to summarize the central results of this study. The reader interested in further details is referred to the references cited.

There are now between about twenty and several dozen vendors selling products under the label ‘low-code.’ It was, of course, beyond our scope to undertake an exhaustive review of all these solutions, so that a limited number of LCPs had to be selected for study. Accordingly, no claim of representativeness can be made. Because the study is intended to be explorative in nature, however, we argue that this restriction is justifiable. A number of criteria were considered in the selection of LCPs. The overriding intent was to cover a spectrum as broad as possible. We therefore began with a preliminary market study, grouping existing LCPs into four rough categories according to their general character and purpose (cf. below). Afterwards, we chose the LCPs so that at least one candidate from each category was considered. Moreover, we made sure to cover vendors of different size and market influence, as well as LCPs intended for different target audiences. In case of doubt, large vendors were given the priority, based on the assumption that these figure prominently in shaping the concept of LCPs. More details on the selection process are found in the original study. Limitations of the analysis and related work are indicated at the end of this section; and for the complete details, again, see the references cited above.

Our exploratory analysis of existing low-code platforms has revealed a number of features found in these systems, and it has occasioned several general observations. We will now discuss the main findings of our analysis, offering a critical assessment of the trend.

No new technology. Summing up the previous points, we arrive at the finding that most components of LCPs are, in and of themselves, neither radically new nor innovative in any way. To the contrary, what is actually provided in these environments are well-known tools and components for software development which have been used, in varying forms, for decades. Also, many low-code products have, in fact, existed for many years, and are now merely rebranded. In this respect, we therefore agree with Cabot who concluded: “I do not believe there is any fundamental technical contribution in low-code trend” (Cabot 2020, p. 536).

Conceptual modeling is not at the core of marketing, but at the core of the platforms. Another key finding concerns not the technology itself, but the way in which it is sold. As our analysis has indicated, conceptual modeling components are among the most important components of low-code platforms and one of the principal ways in which they are able to decrease the need for traditional coding. This is the exact approach of the field of MDD, where the vision has been that conceptual models are used to "reduce the gap between problem and software implementation domains through the use of technologies that support systematic transformation of problem-level abstractions to software implementations" (France and Rumpe 2007, p. 37). The modeling languages provided by the LCPs, however, are rather simplistic, lagging behind the state of the art in research on conceptual modeling.

Incomplete account of related research. The design of available LCPs has, evidently, derived inspiration from several lines of research on IS design and implementation, but, surprisingly, ignored others. A field from which most LCP vendors have drawn quite extensively is, as underlined above, that of model-driven development. There are also more or less pronounced similarities to other research-based approaches, although the exact technical concepts and procedures are not usually adopted. This is true, for example, of design constructs from research on ‘visual programming’ (e.g., Costagliola et al. 2004; Ingalls et al. 1988), technical concepts to support ‘weaving’ reusable services into customized ones (e.g., Besova et al. 2012; Bergel and Fabry 2009), and the more recent vision of ‘on-the-fly computing’ (Karl et al. 2020). Remarkably, other well-known lines of investigation have been ignored altogether. Most importantly, as already stressed, this concerns work on reference models (e.g., Becker and Delfmann 2007; Fettke and Loos 2007) as well as work on domain-specific modeling languages (e.g., Kelly and Tolvanen 2008; Frank 2013). Both reference models and DSMLs can promote the productivity of systems design significantly, as they incorporate domain knowledge.

Risk of lock-in effects. In most cases, the representations generated in one LCP cannot be used in another. This presents a serious threat to the protection of investment and may lead to dead ends when a vendor stops supporting a platform (as is the case with AppMaker, which Google has recently abandoned).

A number of opportunities for research are tied to the emergence of low-code development platforms. One reason is that methods and theories for the construction and adaptation of organizational information systems are at the very core of business information systems research. Another reason is that all areas of our social reality continue to be permeated by software. Thus, much in the spirit of low-code development, approaches are needed to empower people – not just the traditional “user” – to understand and modify the software shaping their work environment and, more and more, their entire lives. The following list of research opportunities is intended to illustrate the scope of inspiring research topics related to the low-code trend.

Effects on organizational behavior: Approaches to foster end-user computing effectively blur the traditional boundaries between developers and users. This is likely to affect organizational decision processes, patterns of collaboration, and roles surrounding IS design and use. While these matters have been the subject of early studies on end-user computing (Amoroso, 1988), the digitization of work environments as well as the average levels of computer literacy have changed considerably since then. This leads to research questions concerning the future conception of IT management in general, and the organization of software projects in particular.

Our analysis of low-code platforms did not produce evidence that the individual components of low-code solutions are radical innovations. In many ways, they lag behind the frontiers of research on software design, implementation, and maintenance. What distinguishes these platforms is that they integrate, in one environment, multiple well-known and traditional system design components so as to reduce the efforts of routine tasks in implementing business applications within the confines of certain, more or less restrictive frameworks. As such, LCPs can promote software development productivity if all the requirements of a given project can be satisfied within the predefined, immutable framework of a certain LCP and all other pertinent technical and economic conditions are fulfilled, too. Developing methods for the careful assessment of these conditions is an important subject for future research.

Moreover, the momentum generated by the low-code trend gives rise to various other inspiring research opportunities lying not only at the core of our discipline, but also at the cross-sections with other disciplines. A most notable opportunity lies in the fact that the attention directed at low-code platforms may contribute to the revival of conceptual modeling. As we have shown, conceptual modeling is one of, if not the single most important ingredient of present-day low-code platforms – even though vendors rarely declare themselves as offering modeling environments. Business information systems research is well positioned to seize this opportunity, since it is the only discipline that takes the design and analysis of domain-specific conceptual models as one of its fundamental tasks.

The term ‘low-code’, however, is problematic. It is currently used in an inconsistent manner, being deployed to sell vastly heterogeneous development environments. While we do not think it is advisable to prescribe practitioners what terminology to use, we believe that it is our responsibility to critically reflect on whether terms are suitable for incorporation into a proper technical terminology. We do not think the term ‘low-code’ at present satisfies the criteria required of a scientific concept. After all, language is our most important tool, and we should beware of compromising it.