Challenges of Low-Code/No-Code Software

Development: A Literature Review

Karlis Rokis and Marite Kirikova(B)

Institute of Applied Computer Systems, Riga Technical University, Riga, Latvia

[email protected], [email protected]

Abstract. Low-code/no-code software development is an emerging approach

delivering the opportunity to build software with a minimal need for manual
coding and enhancing the involvement of non-programmers in software devel-
opment. Low-code principles allow enterprises to save time and costs through a
more rapid development pace and to improve software products quality by bring-
ing closer together business and information technologies as well as promoting
automation. Nevertheless, the low-code/no-code approach is a relatively new and
continuously progressing domain that requires understanding of existing chal-
lenges and identification of improvement directions. In this paper, challenges in
the low-code software development process and suggestions for their mitigation
are identified and amalgamated with the purpose to deliver insights into the current
state of the low-code/no-code development process and identify areas for further
research and development.

Keywords: Low-code · No-code · Software development · Requirements ·

Low-code development platform · Citizen developer

1 Introduction
Low-code development is a software development approach that merges minimal hand-
coding, graphical user interface, and visual abstraction. Development of applications
is based on model-driven engineering principles, utilizing benefits delivered by cloud
infrastructure (as development platforms are usually offered as Platform-as-a-Service),
visual high-level abstraction, and automatic code generation [1, 2]. Practitioners use the
term “no-code development” as a synonym to refer to low-code development practices
[3]. Hereafter, terms low-code and no-code are not particularly distinguished and using
term low-code also refers no-code and vice versa.
Low-code software development (LCSD) is an emerging trend as it proposes to
address one of the main causes of delayed development – shortage of professional
developers – by enabling non-programmers and non-technical personnel, called “citizen
developers”, to participate in the development process [1, 2]. Citizen developers are
experts in a particular domain and system’s functionalities meaning that they know and
can define requirements. And LCSD through minimization of manual coding and by
emphasizing visual platforms interfaces also enables participation of citizen developers
in software development lifecycle phases – design, development, testing, deployment,

© The Author(s), under exclusive license to Springer Nature Switzerland AG 2022

Ē. Nazaruka et al. (Eds.): BIR 2022, LNBIP 462, pp. 3–17, 2022.
https://doi.org/10.1007/978-3-031-16947-2_1
4 K. Rokis and M. Kirikova

and maintenance. Although citizen developers, on the one hand, are considered as the
main users of low-code development platforms (LCDP), they, on the other hand, lack
programming knowledge and consequently this is a limiting factor for LCSD adaption
and application by citizen developers [2, 4, 5].
Besides the advantage of enabling citizen developers to participate in the software
development process, there are multiple other benefits as well. Low-code platforms
enable the rapid translation of business requirements and development into the appli-
cation as well as the possibility to quickly make the adjustments as there is no need
for extensive manual coding. Additionally, due to reduced time spent on the develop-
ment cycle, also development costs are reduced [3, 5]. However, several challenges in
low-code software development should be considered and they are covered in this paper.
In the paper, a literature review has been conducted to amalgamate challenges in low-
code software development and find, in the current literature, mitigation suggestions or
directions regarding these challenges. The remainder of the paper is structured as follows:
Sect. 2 includes the description of the research method. In Sect. 3, a background regarding
low-code software development and related works is given. Section 4 covers identified
challenges and mitigation suggestions followed by conclusions of the review in Sect. 5.

2 Methodology

A literature review is a helpful instrument to understand a currently existing body of

knowledge in a specific domain, to identify the gaps and to see the direction in which fur-
ther research is required [6]. The review has been conducted according to the approaches
described in Levy et al. “A systems approach to conduct an effective literature review in
support of information systems research” [6]. The goal of the paper is to review existing
literature to identify challenges in the low-code/no-code software development and to
find, in the current literature, suggestions, solutions or proposals on possibilities to miti-
gate and overcome these challenges. The following research questions were established
to reach the defined goal:
RQ1: What challenges for low-code software development and implementation can
be identified in the current literature?
RQ2: What solutions, actions or ideas could help to overcome these challenges?
The retrieved articles were validated against the selection criteria. The inclusion and
exclusion criteria are described in Table 1.
Based on the topic of the paper and research questions, the keywords and search
string were formed. Used keywords were “low code” and “no code” (joined with Boolean
search connector “OR”) and “develop*” and “implement*” (joined with operator OR).

Table 1. Selection criteria of the articles

Selection No Criteria
Inclusion I1 The article covers the low-code/no-code software development
Exclusion E1 The article is not published in English
E2 The full text of the article is not accessible
E3 The article does not provide an answer to any of the research questions
 Challenges of Low-Code/No-Code Software Development 5

Table 2. Number of results per scientific library

Database Number of results Primary studies

IEEE 104 10
ACM 51 11
ScienceDirect 22 1

The automatic search was applied for the title, abstract and keywords fields of the papers.
The final search string was formed:

("low code" OR "no code") AND (develop* OR implement*)

An initial keyword-based search was performed in the last quarter of 2021 in scien-
tific databases: IEEE Xplore Digital Library, ACM Digital Library and ScienceDirect.
These databases, as suggested in [7], are considered as relevant libraries in the software
engineering domain. In the ACM Digital Library and ScienceDirect, the article type
field was set to “Research Article”. Additionally, the results not related to the domain
of information technology (for instance, natural science, medicine, and other domains)
were removed as they are not relevant for this review. In total 177 articles were found
by the automatic keyword-based search. The number of found articles per scientific
library is displayed in Table 2 column “Number of results”. The results were reviewed
by applying inclusion and exclusion criteria to the title and abstract. However, for a few
articles to ensure they are relevant for the literature review, additionally the full text
was reviewed. In the end, 22 articles were identified as primary studies relevant for the
review based on keyword search.
In the article [6] it is emphasized that the keyword search is not sufficient for a
literature search process, but it is just an initial step. As a second search strategy, the
backward search was applied. Within this search, the references of the identified primary
articles were reviewed. One additional study was identified through the backward search
process.
In total 23 unique articles were selected for structured literature review. Gathered
articles have been published from 2019 to 2021 showing that the most recent literature
is included in the review.

3 Background and Related Work

In the following section, the general concepts that will be used further in the work are
explained.
The development process of low-code/no-code applications can be divided into sev-
eral phases. The initial and continuous step throughout the development process is
Requirements analysis. The first phase – Data modelling – involves the configuration of
the data schema for the application (entities creation, definition of relations, constraints,
and dependencies). The following phase is a Definition of a user interface (UI Design).
This involves the creation of forms and pages that are applied for view definition of
application. In the later stages, the definition of user access and security management
6 K. Rokis and M. Kirikova

for forms, pages, entities, and components is performed. For particular forms or pages,
different workflows – business logic – might be needed and those are realised by imple-
menting different operations for interface elements. These actions are performed in the
third development phase called Specification and implementation of business logic rules
and workflows. In the fourth phase, the Integration of external services is established.
In such a way it is possible to consume external services directly in low-code software
development by using application programming interfaces (APIs) provided by third par-
ties. Then the testing and application deployment is performed. In the end, the customer
feedback and defined additional features are gathered [1, 2].
Nowadays agile methodology is a widely used approach and its adoption is increasing
[8]. Low-code/no-code software development process fosters the building of applica-
tions, gathering of users’ feedback and implementing changes at a rapid pace delivering
continuous increments and improving customer satisfaction. This matches the approach
of agile development. Based on that, low-code software development stages can be
related to the phases of the agile software development process [1]. To show how these
stages refer to each other the article [1] proposes and presents the relation among them.
A modified visualization of this relation is displayed in Fig. 1. The inner (yellow) circle
groups the low-code software development stages, but the agile development stages are
marked with the outer (light blue) area. Corresponding stages between methodologies
are filled with the same pattern. In further work, where applicable, we will refer to the
agile development stages as it is a commonly used methodology and low-code software
development conforms well to agile principles such as continuous delivery and customer
satisfaction. In addition, multiple LCDPs are equipped with facilities supporting agile
development methodology [1, 2, 8, 9].
Low-code software development is accomplished on low-code software develop-
ment platforms. These platforms are cloud- or on-premise-based and applications are
developed through visual interfaces, the use of prebuilt components, their customiza-
tion, and configurations of the settings. Using visual diagrams, high-level abstraction,
declarative languages, and, in particular cases, also manual coding, the developers define

Fig. 1. Development stages in the agile and low-code software development process (adapted
from the description in [1])
 Challenges of Low-Code/No-Code Software Development 7

user interfaces, business logic, and data services [2, 4, 5]. The architecture of a low-code
development platform is made of four main layers: (1) application layer, (2) service
integration layer, (3) data integration layer, and (4) deployment layer [2].
The top, application, layer provides a graphical environment for users direct inter-
action to define the developed application, its user interfaces, and behaviour. This layer
includes toolboxes and widgets for interface development as well as mechanisms for
authentication and authorisation [2].
To utilise different services, for instance, using APIs, there is a dedicated layer
distinguished for that called the Service integration layer [2].
The Data integration layer covers data integration issues allowing to operate and
manipulate data coming from different sources [2].
The Deployment layer provides that the developed applications (depending on the
applied platform) can be deployed either on cloud or on-premises environments [2].
If this architecture is expanded, a low-code platform consists of multiple components
that can be arranged in three tiers. The first one is application modeller for applications
specification using constructs and abstraction (including, for instance, widgets, con-
nectors, business logic flows, data model, security rules, and others), the second tier
forms server-side and its functionalities (for instance, platform server, compilers, opti-
mizers, code generators, services), and the third tier is integrated external services (for
instance, database servers, third-party systems, APIs, microservices, model repositories,
and collaboration platforms) [2].
Low-code development has already been applied in multiple domains. The article
[3] by an empirical study of forum posts, has identified, from practitioners’ perspective,
such application domains as e-commerce, business process management, social media,
customer relationship management, extract, transform and load (ETL) processes, enter-
tainment, content management systems, robotic process automation, and medicine. Also,
in scientific literature, wide variety of application domains can be identified. In [9] Mar-
tins et al. develop a platform for human resource management; in [10], Oteyo et al.
build the application in the domain of agriculture; Ihirwe et al., in [11], present the
state of research in the Internet of Things (IoT) domain; in [12], Waszkowski describes
the application in business process automation in manufacturing; Arora et al., in [13],
identify such potential application domains as banking and communication; Varajão, in
[14], shows the application in public health area; in [15], Kourouklidis et al. tell about
application possibilities in machine learning model monitoring; Di Sipo et al. propose,
in [16], implementation in the domain of recommender systems; in [17], Iyer et al.
present an application in the geospatial domain; and Daniel et al., in [18], present the
development framework for chatbot implementation.
Some works review challenges regarding the low-code software development or
application of low-code development platforms. Sahay et al., in the technical survey
“Supporting the understanding and comparison of low-code development platforms”
(2020), by reviewing multiple low-code platforms and by developing benchmarking
applications on them identify such challenges as interoperability, extensibility, and scal-
ability issues as well as a need for extensive learning that is introduced by platforms
characteristics [2]. A team led by Khorram worked on a paper discussing “Challenges &
Opportunities in Low-Code Testing” (2020) comparing and analysing testing facilities
in LCDP market leader platforms. Specific challenges, for instance, limited capabilities
8 K. Rokis and M. Kirikova

of the low-code testing framework, automated testing, and others were identified and
grouped and opportunities for future work were delivered [4]. In the paper “An Empiri-
cal Study of Developer Discussions on Low-Code Software Development Challenges”
(2021) by al Alamin et al., by analysing the online developer forum Stack Overflow
posts, identified the low-code software development challenges faced by practition-
ers using nine popular low-code development platforms. The paper revealed the most
challenging topics, grouped them by their categories (whether a topic is related to cus-
tomization, platforms adoption, database management or integration) and development
stages proposing the most difficult low-code software development areas from a prac-
titioners’ perspective [1]. A similar empirical study “Characteristics and Challenges
of Low-Code Development: The Practitioners’ Perspective” was conducted by Luo Y.
et al. who expanded analysis with another forum Reddit and the focus on development
characteristics, benefits, and disadvantages in low-code development [3].
To the best of the authors’ knowledge, currently, there is no literature review available
that amalgamates challenges in low-code/no-code software development and possible
ways or improvements that could help to overcome them in a stage-based manner. The
findings presented further in this paper could be helpful for (i) practitioners to oversee
challenges, and see how to meet and handle them, (ii) vendors to realise weaknesses that
should be addressed and further development directions, and (iii) research community
to identify areas that might require further research.

4 Challenges in Low-Code/No-Code Development

This section provides an answer to the research questions about the challenges of the
low-code software development process and existing or possible suggestions, actions,
solutions or ideas that could help to mitigate them. To structure the content of identified
challenges from papers related to low-code/no-code development, the challenges are
grouped according to software development phases described in Sect. 3. In Table 3, the
identified challenges are presented according to these stages, and, next to them, also
possible ways, found in the literature, that could help to overcome these challenges are
recorded. Positioning of the text is made so that it would be visible which treatments
refer to several challenges and which to just a specific challenge or a smaller group of
challenges.
Further in this section, the challenges of each stage and their mitigation possibilities
are discussed in separate dedicated subsections. LCSD challenges, which differ by the
level of complexity, are not distributed evenly among development stages [1]. Consider-
ing count of identified challenges as well as their difficulty, more attention to challenges
related to design and application development phases has been paid in the related work
[1, 3].

4.1 Requirements Analysis

Requirements Analysis is the initial step to identify users’ expectations regarding soft-
ware to be developed [1]. The importance of requirements specification is high – require-
ments might influence the selection of the right platform and the validation (for instance,
 Challenges of Low-Code/No-Code Software Development 9

Table 3. Challenges and mitigation possibilities

Phase Challenges Suggestions for mitigation

Name Studies
Requirement Requirements [1, 3, 4, 11] • Development of minimum viable
analysis specification product [5, 14]
• Requirement management tools [1]
• A successful adaption of low-code
technologies [5]
Changing [5, 14]
requirements
Planning Selection of the [10] • Implementation of standards [2]
platform • List of features for platforms
comparison [2, 10, 11, 19]
Vendor lock-in [2–5, 18]
Application Extensibility [2, 18] • Implementation of standards [2, 11]
design limitations
Interoperability [2, 11]
Consideration of [2, 20] • Further development of low-code
scalability development platforms [20]
UI design [1] • Address knowledge gap [1]
• Elaborated platforms’ documentation
[1]
Data storage [1]
design
Development Implementation of [1, 3] • Elaborated platforms’ documentation
business logic [1]
• Learning resources [1–3]
Integration [1, 3]
No access to [3] • Further development of low-code
source code development platforms [3, 20]
Customization of [1, 3, 21, 22] • Recommender • Automated
UI systems for conversion of
development [23] design elements
[21, 22]
Debugging [1, 3] • Solutions for
debugging [1]
(continued)
10 K. Rokis and M. Kirikova

Table 3. (continued)

Phase Challenges Suggestions for mitigation

Name Studies
Testing Limited testing [1, 4, 11] • Elaborated platforms’ documentation
and analysis [1]
support • Introduction of general low-code
testing framework [4, 11]
• Test automation [4, 13, 24, 25]
Dependence on [1, 4, 11]
third-party testing
tools
Testing of [4]
non-functional
requirements
Deployment Performance [1, 3] • Elaborated platforms’ documentation
[1]
Configuration [1]
issues
Accessibility [1]
issues
Version control [1] • Use of
repositories [1, 2]
Maintenance Debugging [1, 3] • Elaborated • Solutions for
platforms’ debugging [1]
documentation
[1]
Use of [1, 19] • Learning resources [1]
maintenance
features

in a form of tests) whether the software meets users’ expectations are performed based
on specified requirements [3, 4]. The literature shows that support of requirements
specification differs from one platform to another. For instance, the article [1], which
focuses on the top nine low-code software development platform market leaders, states
that platforms provide tools for requirement management, however [11] points out that
requirements specification lacks the focus in most platforms dedicated for the domain
of IoT. That means that requirements specification and management, depending on the
used platform, can be challenging and practitioners would value having a requirements
management tool in the low-code software development platform.
The changes of requirements might be considered as another challenging aspect men-
tioned in the literature within the requirements analysis phase as they have an impact
on the software design [5]. However, successful application of the low-code principles
which delivers an opportunity to develop at a rapid pace, handle this aspect well by
 Challenges of Low-Code/No-Code Software Development 11

enabling such exploratory requirements validation techniques as prototyping and build-

ing a minimum viable product. The low-code approach enables an opportunity to quickly
develop a minimum viable product that can be validated against customer requirements
to understand the value of it before putting an effort and resources into the development
of functionality or features [5]. For instance, as described in [14], low-code princi-
ples allowed to quickly create initial functional prototype and to continuously deliver
the functional solution the following day and to maintain the quality of the software
artefacts even though requirements were constantly evolving.

4.2 Planning
The planning phase includes analysis and planning of feasibility, complexity, risk, depen-
dencies, and timeline taking into consideration the operational aspects. The challenge
identified in the literature in this phase is related to the selection of a suitable platform as
there is the large number of platforms available in the market [2, 10]. The practitioners
are concerned about related costs, the learning curve, supported platform features and
functionality in development, deployment, and maintenance [1].
By analysing low-code platforms, the article [2] proposes 35 features that could help
to compare and select an appropriate platform. Analysed features cover such issues as
graphical user interfaces, support of interoperability, security, opportunities on collabo-
rative development, reusability possibilities, scalability, mechanisms to specify business
logic, application build mechanisms, deployment support, and what kind of application
the development platforms support [2]. In addition to the features proposed by [2], mul-
tiple additional criteria for comparison have been included in other sources, for instance,
features for specification of roles and users, support to requirements specification and
verification, support of testing and validation, availability of artificial intelligence com-
ponents [11, 19]. As noticed in [11], additional characteristics relevant to a particular
domain can be promoted (for instance, as in the case of IoT, characteristic “focus on
“The thing” layer” is essential for comparison). Application of such feature list and
comparisons as proposed in [2, 11, 19] can be found in literature in practical examples.
For instance, article [10], which covers the concern about the selection of the tool for the
development of agriculture applications, uses similar criteria for making selection deci-
sions. Also, the taxonomy for comparison of low-code development platforms provided
by [2] has been put into the practice in experience report in [26] developing two scenar-
ios on main market platforms. This shows that a feature list (taxonomy) for comparison
and selection of platforms could be useful for practitioners as the basis for informed
selection decisions [2].
Concerns regarding vendor lock-in which means that the platforms user is restricted
and dependent on the provider, is one of the main reasons why companies are not
adopting low-code platforms [5]. In article [18], the example of a chatbot platforms
selection describes that companies end up in vendor lock-in by choosing a particular
platform that is coupled to a particular engine, but such situations could be avoided by
introducing channel and platform-independent frameworks. Vendor lock-in is related to
such design aspects as extensibility and interoperability (see Subsect. 4.3 Application
Design for detailed explanation) and could be mitigated by standardization, enhancing
information exchange, and sharing of artefacts among different platforms [2].
12 K. Rokis and M. Kirikova

4.3 Application Design

The specification of design which is based on applications requirements is determined

in the application design phase. Design is considered regarding architecture, modularity,
extensibility, scalability, and other aspects [1]. In the current literature, in this phase the
following multiple low-code/no-code software development challenges are identified:
limitations of extensibility and interoperability and considerations regarding scalability,
data storage, and user interface design.
As identified in the literature, practitioners can expect that they will face extensibility
limitations which refers to the possibility to refine or extend the provided functionalities
by the tool, as new function addition to proprietary, closed source platforms is very
difficult if not impossible [2, 18]. Also, interoperability – the tool’s ability for internal
(among components) and external (among services) information exchange – is a chal-
lenging aspect. Due to the lack of standards and reason that platforms are closed source,
the interoperability possibilities are impeded causing limitations to architectural design
and developed service and other artefact sharing. Both aspects contribute to concerns
regarding vendor lock-ins making customers dependent on platform and vendors’ deci-
sions [2, 3]. To mitigate this challenge, it would be valuable to propose and apply the
standards. The example given by [11] shows that it is possible to propose and introduce
the standard (IoT reference model), which is adopted by different tools, even in such a
complex domain as IoT. This example could serve as a starting point for further explo-
ration and expansion of the standards covering interoperability issues [11]. Additionally,
as stated under the Planning phase, it is relevant to consider aspects of extensibility and
interoperability in platform selection criteria.
Another challenge in this phase is related to low-code development platforms scal-
ability that covers platform ability to scale regarding the number of users, data traffic
or data storage [2]. As explained in [20] users, regarding low-code platforms, respect
their responsiveness and the ability to process complex procedures in a reasonable time.
Therefore [20] proposes research lines for further development of low-code platforms to
provide the multi-tenant environment for collaborative work, extend a model processing
paradigm scaling possibility for a large number of elements and ensure engineers with
a set of criteria for the selection of the appropriate model transformation engines in
multi-tenant execution environments.
Practitioners have pointed out that during application design they face challenges
regarding the design of user interfaces and data storage [1]. The user interface design
process is complex, and it involves designing expected behaviour, “look and feel” of the
system and it requires certain skills of the designer [22]. This seems to be challenging for
one of the main low-code software platform user groups – citizen developers – as they
might lack knowledge and design process experience [16]. Also, the challenge of data
storage design, use of on-premises data sources, data migration to the platform, could be
rooted in citizens developers’ knowledge gap or information availability, for instance,
in platforms’ documentation, as platforms, in general terms, are designed so that they
support different data storage configurations [1, 19]. The authors of this work could not
identify a specific direction of actions in current literature that could help to mitigate
these design challenges for citizen developers, however, the reduction of the knowledge
gap, as well as the availability of elaborated documentation, can be suggested and might
reduce the occurrences of these challenges.
 Challenges of Low-Code/No-Code Software Development 13

4.4 Development

In this phase, the actual software is developed. Practitioners experience different kinds of
challenges when customizing user interface, implementing business logic, integrating
with third-party services, or solving more complex development issues that require
access to code [1, 3]. For the topics related to user interface customization possibilities,
implementation of business logic and integration, one of the identified reasons in the
literature is incomplete or even incorrect documentation as well as the lack of learning
resources, for instance, tutorials, of the platforms. Also, multiple platforms have non-
intuitive interfaces, limited drag-and-drop capabilities and they require knowledge in
software development, resulting in a high learning curve for the adoption of low-code
technologies which is a challenging aspect for citizen developers [1–3]. However, the
situation seems to be different in the case of developers with some coding experience. In
the article [9], which describes the development of the low-code application for human
resources self-service using the OutSystems1 platform, the learning curve is identified
as low for the team of developers, allowing to assume that the level of knowledge may
impact the learning and adoption process of the technology.
In some cases, limited flexibility of the functionality and design of low-code devel-
opment platforms arises the challenge of solving more complex development issues. If
the platform does not provide enough customization features that may result in a need
to write custom code spending more time, rising complexity, and requiring compro-
mises on the product functionalities [3]. Additionally, challenges of third-party services
integration depend on the platforms’ extensibility capabilities which were discussed in
Subsect. 4.3 Application Design [2].
Nevertheless, to mitigate previously stated development challenges from the learning
and adaption perspective, platform vendors should provide elaborated documentation
and learning resources. At the same time, practitioners should consider these challenges
and realise possible trade-offs for low-code software development [1]. Another potential
solution to assist citizen developers during the development stage is proposed in paper
[23] by suggesting a recommender system that would use the captured knowledge from
previously developed applications.
User interface customization challenges can be also viewed from another perspective
in cases when user experience and user interface designers and the team of front-end
developers collaborate in the process of converting user interface design elements and
their customizations (designed using dedicated tools) into the low-code platforms’ rep-
resentation. This step requires manual processing which is not efficient and can end up in
the inaccurate translation of customization, errors or gaps between the initial design and
the result. An approach to mitigate this is the automated conversion of design artefacts
into user interface components [21, 22]. Articles [22] and [21] described that such tools
delivered improvements in terms of efficiency.
Another challenge that should be taken into consideration and accepted in low-
code software development is difficulties related to debugging due to the graphical
representation of software development kits in low-code development platforms [1,
3], however, current literature does not explain whether specific mechanisms or tools

1 https://www.outsystems.com.
14 K. Rokis and M. Kirikova

(for instance, debuggers) are applied although it is suggested for practitioners to adopt
strategies to learn the process of debugging [1].

4.5 Testing
This phase includes tests on the developed system to verify that all the stated requirements
are realized [4]. Multiple challenges are identified in the low-code software development
testing phase. The practitioners report a lack of documentation, particularly, to run auto-
mated tests, test coverage, and the use of third-party testing tools [1]. These challenges
could be mitigated by providing elaborated documentation.
To cover all testing activities, the largest low-code development platforms provide
the opportunity for integration of third-party testing tools, however, due to dependency
on these tools, there is limited involvement of citizen developers as they do not have the
required level of knowledge. At the same time platforms have limited low-code testing
frameworks and analysis support [4, 11]. Also, testing of non-functional requirements
in low-code platforms is often neglected. Overall, these challenges could be addressed
by researching and implementing a low-code testing framework that would cover all
testing activities, would be reusable for other platforms, and be suitable also for citizen
developers. Another suggestion for further research, concerning the low-code software
development testing phase, is test automation. However, this automation due to the
involvement of citizen developers should be provided with low technical knowledge
dependency [4].
Regarding the support of testing and analysis activities, paper [24] presents a con-
cept for executable tests generation for Process-Driven Applications to reduce manual
test creation delivering time saving on this process and enabling citizen developers to
generate test codes independently. Also, some platforms, for instance, Sagitec Software
Studio S32 , implementing Sagitec Test Studio, focus on reducing the creation of manual
test cases and improving test executions and coverage [13]. Another article [25] reports
on a prototype of a mocking mechanism based on the OutSystems platform to eliminate
dependencies and to allow to test applications in isolation enhancing testing abilities of
the platform. However, dependence on a specific platform as a downside can be men-
tioned for the last two proposals and it would be valuable to have such tools reusable for
other platforms [4].

4.6 Deployment
Typically, low-code platforms integrate different components for development and
among them also deployment assistants to perform the deployment easily and success-
fully [1, 19]. Nevertheless, practitioners share challenges regarding issues of deployment
configuration, accessibility, and performance (slow loading and publishing) [1, 3]. In the
current literature, particular mitigation opportunities to address these challenges are not
provided, however, paper [1], through the example of deployment issues, points out the
incomplete platform documentation that should be improved. Also, version control is
identified by practitioners as a challenge, although platforms, for this purpose, provide
repositories for storing artefacts and handling version control tasks [1, 2].
2 https://www.sagitec.com/resource-development-tools-s3.
 Challenges of Low-Code/No-Code Software Development 15

4.7 Maintenance
After the application is released, it needs maintenance support, to rapidly implement
changes for the developed solutions or features to provide continuous availability. Low-
code platforms are characterized as easy maintainable [1, 5]. In this phase debugging
appears as a challenge (see Subsect. 4.4 Development) [1, 3]. Additionally, paper [1]
indicates challenges regarding such platforms’ maintenance features as monitoring, col-
laboration, and others, for instance, such as machine status and anomalies monitoring
dashboards in ADAMOS platform3 [5] and roles management. Reviewing previously
identified challenges and suggestions in the paper [1], we can conclude that also for
these challenges elaborated documentation and information availability could help to
some degree to overcome them.

5 Conclusion
The objective of this literature review was to survey existing literature to identify chal-
lenges in the low-code/no-code software development and to find suggestions, solutions,
and proposals on possibilities to mitigate and overcome these challenges. The review
included 23 sources used to identify challenges and suggestions for their mitigation. The
obtained results were organized according to seven agile software development phases.
Low-code technologies are a recently emerging trend and, even though low-code
software development provides multiple benefits, there are plenty of challenges and
improvements opportunities.
The literature review shows that low-code/no-code software development and tech-
nologies have several challenging aspects that call for further research and improvements,
for instance methods and approaches for supporting citizen developers, minimal viable
product based requirements management, and frameworks for standardization.
Multiple challenges to some degree could be mitigated by vendors by improving
platforms’ documentation and learning resources. Vendors should continue to work on
platforms development so to address challenges and limitations identified in the design
(e.g., extensibility, interoperability, scalability, and others) and development phases (cus-
tomization and implementation options, integration possibilities, and others) to meet
users expectations. Attention should be paid to improving the design and customization
of the user interface as any custom adjustments which are not directly supported by the
low-code platform may rise challenging aspects for developers or require compromising
the functionality of the application.
Current review of challenges and their mitigation opportunities in low-code develop-
ment suggests that practitioners should identify and address the knowledge gap, evaluate
and analyse the low-code technologies adoption, and explore its opportunities to release
its potential.
The whole low-code community that includes researchers, vendors and practitioners
may benefit from joint efforts in considering the implementation of standards, introduc-
ing common frameworks (for instance, for testing) and developing new tools to enhance
further progress of low-code technologies.
3 https://www.adamos.com/en/.
16 K. Rokis and M. Kirikova

References
1. al Alamin, M.A, et al: An empirical study of developer discussions on low-code software
development challenges. In: Proceedings – 2021 IEEE/ACM 18th International Conference
on Mining Software Repositories, MSR 2021. Institute of Electrical and Electronics Engineers
Inc., pp. 46–57 (2021)
2. Sahay, A., Indamutsa, A., di Ruscio, D., Pierantonio, A.: Supporting the understanding and
comparison of low-code development platforms. In: Proceedings – 46th Euromicro Confer-
ence on Software Engineering and Advanced Applications, SEAA 2020. Institute of Electrical
and Electronics Engineers Inc., pp. 171–178 (2020)
3. Luo, Y., et al: Characteristics and challenges of low-code development: the practitioners per-
spective. In: International Symposium on Empirical Software Engineering and Measurement.
IEEE Computer Society (2021)
4. Khorram, F., Mottu, J., M., Sunyé, G.: Challenges & opportunities in low-code testing. In:
Proceedings – 23rd ACM/IEEE International Conference on Model Driven Engineering Lan-
guages and Systems, MODELS-C 2020 – Companion Proceedings, pp. 490–499. Association
for Computing Machinery Inc (2020)
5. Sanchis, R., García-Perales, Ó., Fraile, F., Poler, R.: Low-code as enabler of digital transfor-
mation in manufacturing industry. Appl. Sci. (Switzerland) 10, 1–7 (2020). https://doi.org/
10.3390/app10010012
6. Levy, Y., Ellis, T., J.: A systems approach to conduct an effective literature review in support
of information systems research. Inf. Sci. 9, 181–211 (2006). https://doi.org/10.28945/479
7. Kitchenham, B., Charters, S.: Guidelines for performing Systematic Literature Reviews in
Software Engineering. Keele, Staffs (2007)
8. Fitriani, W., R., Rahayu, P., Sensuse, D., I.: Challenges in agile software development: a sys-
tematic literature review. In: 2016 International Conference on Advanced Computer Science
and Information Systems, ICACSIS 2016, pp. 155–164. Institute of Electrical and Electronics
Engineers Inc. (2017)
9. Martins, R., et al: An overview on how to develop a low-code application using OutSys-
tems. In: Proceedings of the International Conference on Smart Technologies in Computing,
Electrical and Electronics (ICSTCEE 2020), 9–10 October 2020, Virtual Conference (2020)
10. Oteyo, I.N., et al.: Building smart agriculture applications using low-code tools: the case for
discopar. In: IEEE AFRICON Conference. Institute of Electrical and Electronics Engineers
Inc (2021)
11. Ihirwe, F., et al.: Low-code engineering for internet of things: a state of research. In: Proceed-
ings – 23rd ACM/IEEE International Conference on Model Driven Engineering Languages
and Systems, MODELS-C 2020 – Companion Proceedings, pp. 522–529. Association for
Computing Machinery Inc. (2020)
12. Waszkowski, R.: Low-code platform for automating business processes in manufacturing. In:
IFAC-PapersOnLine, pp. 376–381. Elsevier B.V. (2019)
13. Arora, R., Ghosh, N., Mondal, T.: Sagitec software studio (S3) – a low code application
development platform. In: 2020 International Conference on Industry 4.0 Technology, I4Tech
2020, pp. 13–17. Institute of Electrical and Electronics Engineers Inc. (2020)
14. Varajão, J.: Software development in disruptive times. Queue 19, 94–103 (2021). https://doi.
org/10.1145/3454122.3458743
15. Kourouklidis, P., Kolovos, D., Matragkas, N., Noppen, J.: Towards a low-code solution for
monitoring machine learning model performance. In: Proceedings – 23rd ACM/IEEE Inter-
national Conference on Model Driven Engineering Languages and Systems, MODELS-C
2020 – Companion Proceedings, pp. 423–430. Association for Computing Machinery Inc.
(2020)
 Challenges of Low-Code/No-Code Software Development 17

16. di Sipio, C., di Ruscio, D., Nguyen, P.T.: Democratizing the development of recommender
systems by means of low-code platforms. In: Proceedings – 23rd ACM/IEEE International
Conference on Model Driven Engineering Languages and Systems, MODELS-C 2020 –
Companion Proceedings, pp. 471–479. Association for Computing Machinery, Inc. (2020)
17. Iyer, C.V.K., et al.: Trinity: a no-code AI platform for complex spatial datasets. In: Proceedings
of the 4th ACM SIGSPATIAL International Workshop on AI for Geographic Knowledge
Discovery, GeoAI 2021, pp. 33–42. Association for Computing Machinery Inc. (2021)
18. Daniel, G., Cabot, J., Deruelle, L., Derras, M.: Xatkit: a multimodal low-code chatbot devel-
opment framework. IEEE Access 8, 15332–15346 (2020). https://doi.org/10.1109/aCCESS.
2020.2966919
19. Bock, A.C., Frank, U.: In search of the essence of low-code: an exploratory study of seven
development platforms. In: 2021 ACM/IEEE International Conference on Model Driven
Engineering Languages and Systems Companion (MODELS-C), pp. 57–66. IEEE (2021)
20. Horváth, B., Horváth, Á., Wimmer, M.: Towards the next generation of reactive model trans-
formations on low-code platforms: three research lines. In: Proceedings – 23rd ACM/IEEE
International Conference on Model Driven Engineering Languages and Systems, MODELS-
C 2020 – Companion Proceedings. Association for Computing Machinery Inc., pp. 441–450
(2020)
21. Bexiga, M., Garbatov, S., Seco, J.C.: Closing the gap between designers and developers in a
low code ecosystem. In: Proceedings – 23rd ACM/IEEE International Conference on Model
Driven Engineering Languages and Systems, MODELS-C 2020 – Companion Proceedings,
pp. 413–422. Association for Computing Machinery Inc. (2020)
22. Pacheco, J., Garbatov, S., Goulao, M.: Improving collaboration efficiency between UX/UI
designers and developers in a low-code platform. In: 2021 ACM/IEEE International Con-
ference on Model Driven Engineering Languages and Systems Companion (MODELS-C),
pp. 138–147. IEEE (2021)
23. Almonte, L., Cantador, I., Guerra, E., de Lara, J.: Towards automating the construction of rec-
ommender systems for low-code development platforms. In: Proceedings – 23rd ACM/IEEE
International Conference on Model Driven Engineering Languages and Systems, MODELS-
C 2020 – Companion Proceedings, pp. 451–460. Association for Computing Machinery Inc.
(2020)
24. Schneid, K., Stapper, L., Thone, S., Kuchen, H.: Automated regression tests: a no-code app-
roach for BPMN-based process-driven applications. In: Institute of Electrical and Electronics
Engineers (IEEE), pp. 31–40 (2021)
25. Jacinto, A., Lourenço, M., Ferreira, C.: Test mocks for low-code applications built with
OutSystems. In: Proceedings – 23rd ACM/IEEE International Conference on Model Driven
Engineering Languages and Systems, MODELS-C 2020 – Companion Proceedings, pp. 530–
534. Association for Computing Machinery Inc. (2020)
26. Gurcan, F., Taentzer, G.: Using Microsoft PowerApps, Mendix and OutSystems in two devel-
opment scenarios: an experience report. In: 2021 ACM/IEEE International Conference on
Model Driven Engineering Languages and Systems Companion (MODELS-C), pp. 67–72.
IEEE (2021)