Low Code Development Platforms

• Low Code Development Platforms are environments that reduce manual coding through visual interfaces, drag-and-drop modeling, and automated code generation.
• They integrate techniques from model-driven engineering, domain-specific languages, and template-based generators to quickly transform models into deployable applications.
• Recent research highlights challenges in customization, interoperability, and vendor lock-in while advancing AI integration and domain-specific extensions.

Low-code development platforms (LCDPs) are environments that facilitate rapid application development and deployment with minimal hand-coding by enabling users to define interfaces, logic, and data integration primarily through graphical user interfaces and visual modeling abstractions. LCDPs originated from model-driven engineering paradigms and have evolved to address the needs of building full-stack enterprise, IoT, AI, and smart applications while attempting to overcome challenges related to integration, extensibility, and vendor lock-in. Recent research explores their technical capabilities, deployment methodologies, community evolution, empirical challenges, and directions for increased openness and interoperability.

1. Architectural Principles and Technical Foundations

Low-code platforms provide a spectrum of abstractions, ranging from visual process modeling and interface builders to domain-specific languages (DSLs) and template-based code generators. The core architectural principle is to expose the essential components of an application—UI, business logic, workflows, data models—via drag-and-drop interfaces, graphical modeling, and declarative configuration, reducing or eliminating the requirement for advanced programming skills (Luo et al., 2021, Ihirwe et al., 2020, Alfonso et al., 22 May 2024).

Model-driven engineering (MDE) concepts underlie many LCDPs, with various approaches to specifying computation-independent (CIM), platform-independent (PIM), and platform-specific models (PSM). Some platforms employ custom modeling notations, such as B-UML in BESSER, which streamline mappings between abstract DSLs and code generation targets (Alfonso et al., 22 May 2024). Others utilize established notations like UML, BPMN, or IFML, often adapting or restricting them to suit code-generation needs and simplify the user experience.

A typical LCDP workflow includes:

• Graphical/model-based specification by business or domain experts at the CIM/PIM levels.
• Automated transformation of models to code (Model-to-Text), using template engines (e.g., Jinja, Xtext).
• Integrated code generators for diverse targets: web/mobile frontends, backend logic (often microservice-based), and database schemas (Alfonso et al., 22 May 2024, Moin et al., 2021).
• Extensible interfaces for adding custom components, generators, or DSLs to accommodate new domains or technologies, e.g., AI, ML, or IoT (Moin et al., 2021, Ren et al., 2022).

2. Data Integration and Polyglot Access

Data integration is a fundamental challenge in LCDPs, particularly when bridging SQL-based abstractions and heterogeneous NoSQL data sources. Research demonstrates that diversity in NoSQL data models and query languages (e.g., documents in MongoDB, wide-columns in Cassandra, key-value in Redis) is difficult to reconcile with the uniform abstractions preferred by low-code platforms (Alonso et al., 2020).

The polyglot data access layer developed for OutSystems exemplifies this approach: it maps native NoSQL models to extended relational schemas, supports nesting and unnesting of arrays and composite structures, and enables embedding native query fragments inside broader SQL queries for advanced operations. Push-down optimization in query translation ensures efficient utilization of native store features while preserving the usability and abstraction expectations of the low-code interface. PostgreSQL’s Foreign Data Wrappers (via Multicorn) manage query dispatch, schema discovery, and data flattening (Alonso et al., 2020).

3. Empirical Developer Challenges

Analysis of developer forums reveals that, despite their abstractions, LCDPs present significant challenges:

• Customization, especially related to dynamic event handling in UIs, is the most frequent and difficult problem, with 75.9% of such Stack Overflow questions remaining without accepted answers (Alamin et al., 2021).
• Configuration and adoption challenges persist, including debugging client-server logic, managing roles, and adjusting to platform constraints.
• Database integration (CRUD operations, schema migration) and third-party API integration (web requests, external services) are substantial but relatively better supported compared to advanced customization.
• Automated testing and maintenance (deployment, CI/CD) are less mature, and developers continue to face difficulties in these areas (Alamin et al., 2022).
• Vendor lock-in and limited access to generated source code impede the transition between platforms, raising concerns for many users (Alfonso et al., 6 Dec 2024).

A notable trend is the increase in platform adoption and API integration questions during rapid digitization events such as the Covid-19 pandemic (Alamin et al., 2022).

4. Domain-Specific LCDPs and Extensions

Specialized LCDPs address vertical domains such as Internet of Things (IoT), AI/ML workflows, and blockchain applications, often combining low-code principles with model-driven automation.

• IoT LCDPs (e.g., Node-RED, Papyrus for IoT, DriotData) manage device/sensor heterogeneity via graphical modeling (often in EMF-based environments), model-driven code generation, and multi-view separation of concerns. However, interoperability and cloud-based MDE remain limited (Ihirwe et al., 2020, Moin et al., 2021).
• Semantic low-code frameworks (SeLoC-ML) introduce ontologies and knowledge graphs to enable device-model matchmaking, automatic code generation, and “recipe”-based rapid prototyping, achieving quantitative reductions in engineering effort (factor of ≥3 in case studies) (Ren et al., 2022).
• In the ML domain, LCDPs facilitate pipeline composition via visual programming and AI-driven natural language interfaces (e.g., LowCoder), which significantly improves both discoverability of operators (from ~30% to 75%) and successful pipeline composition rates (≥82.5%) (Rao et al., 2023).
• For blockchain, LCDPs can generate entire business, application, and technology stacks (as in OutSystems + SimbaChain), but holistic coverage of business logic, smart contract code, and deployment lifecycle remains an open challenge (Curty et al., 2022).

5. Openness, Interoperability, and Community Evolution

Open source LCDPs (such as BESSER) have emerged to address vendor lock-in, transparency, and extensibility concerns. These platforms offer:

• Modular, open metamodels (B-UML) for defining domain structure, object relationships, constraints (OCL), and GUI mappings.
• Multi-syntax support: textual (PlantUML-derived, LLM/generative AI friendly), image-based (LLM-assisted extraction), and direct API instantiation.
• Customizable generator interfaces to emit code for a wide variety of frameworks (Django, SQLAlchemy, mobile/web). Community contribution is intrinsic, with facilities for adding new DSLs/generators and extensible UI/AI components (Alfonso et al., 22 May 2024).

Interoperability across platforms remains a major research focus. Recent work describes a migration framework combining formal export/import routes (using intermediate representations like B-UML) with LLM-based image recognition—extracting PlantUML/B-UML from screenshots where platform-specific exports are lacking (Alfonso et al., 6 Dec 2024). Such approaches bridge incompatible formats, mitigate vendor lock-in, and facilitate incremental migration, with the BESSER framework acting as a pivot for transformations.

6. Broader Impacts and Future Trajectory

LCDPs have redefined the practitioner role, enabling non-engineers to function as hybrid product managers, designers, and developers ("makers"). The platforms align closely with lean startup, agile, and design thinking methodologies, accelerating MVP launch, boosting iteration velocity, and enabling market-driven feature evolution (Heuschkel, 2023).

However, as applications scale, limitations in customization, scalability, and performance may drive a transition to custom development. The increasing incorporation of AI (for natural language to code, image-based modeling, or code synthesis), and deeper DevOps integration to address persistent MLOps and maintainability challenges, are unfolding trends (Alamin et al., 2022, Wang et al., 20 Feb 2025).

A metascience analysis shows that since 2017, low-code publications have outpaced traditional model-driven research, with a diverse, interdisciplinary author base and increasing participation from classical MDE researchers. The field is converging towards more open, collaborative, and cross-domain approaches, promising continued expansion and methodological innovation (Tosi et al., 12 Aug 2024).

7. Technical Summary Table

Aspect	Notable Solutions/Findings	Source
Data Integration with NoSQL	Polyglot data access layer, FDWs	(Alonso et al., 2020)
Model/Code Generation Framework	B-UML, Jinja, PlantUML, Python DSL	(Alfonso et al., 22 May 2024)
Empirical Developer Challenges	Dynamic event handling (75.9% unresolved), high customization demand	(Alamin et al., 2021, Luo et al., 2021, Alamin et al., 2022)
IoT/ML/Blockchain Domain Extensions	ML-Quadrat/DriotData, SeLoC-ML, SimbaChain	(Moin et al., 2021, Ren et al., 2022, Curty et al., 2022)
Openness/Interoperability	LLM-assisted model extraction, B-UML pivot	(Alfonso et al., 6 Dec 2024, Alfonso et al., 22 May 2024)
Platform Evolution/Community	Post-2017 surge, interdisciplinary growth	(Tosi et al., 12 Aug 2024)

By combining graphical abstraction, model-driven automation, extensibility, and increasingly AI-driven interaction, LCDPs are reshaping the practice and reach of software engineering, while presenting active technical and methodological challenges—particularly for integration, scalability, and interoperability—that remain central topics for current research and development.