Just a few years ago, building applications was the domain of specialized IT teams. Today, organizations are increasingly turning to low-code and no-code platforms to keep up with the pace of business change and rising market expectations.
In this context, the concept of citizen developers has emerged – business users who create applications and automations on their own. This approach has quickly gained popularity because it genuinely shortens delivery times, enables faster responses to business needs, and relieves pressure on IT teams.
And indeed, at the level of individual processes, it works very well. The problem only begins when scale increases.
Shadow IT vs. IT Sprawl
It is important to distinguish between related phenomena that are often confused. Shadow IT refers to the use of tools outside the control of the IT department – most often because official solutions cannot keep up with business needs. This often leads to IT sprawl, meaning the uncontrolled growth of systems, applications, and technologies within an organization.
As a result, “data anarchy” emerges – a lack of consistency, standards, and control over information, which starts to exist across multiple, uncoordinated sources.
Challenges for CIOs and CTOs – Growing Complexity of IT Systems
From the perspective of large organizations, the key problem today is not the lack of tools for building applications, but the growing complexity of processes and business models – and, consequently, of the entire IT environment.
Systems are becoming increasingly complex, processing ever-larger volumes of data and relying on multiple integrated technologies. At the same time, IT projects often exceed planned budgets and timelines, and making changes to existing solutions can be costly and risky.
In this reality, low-code is a natural response – it enables faster solution development and more efficient use of organizational resources. However, without the right approach, it can also exacerbate existing problems.
When Low-Code Turns into “Excel 2.0”
In many companies, initial low-code implementations are successful. Applications are created that solve specific business problems and deliver quick results.
Over time, however, a different scenario begins to emerge. More teams build their own solutions, often independently of one another. Data starts to be duplicated, integrations are handled ad hoc, and system architecture loses coherence.
What was meant to organize the IT environment begins to resemble yet another layer – difficult to control and increasingly fragmented.
This is precisely where the risk commonly referred to as “data anarchy” arises.
Are Citizen Developers the Problem?
The simplest answer would be: yes. But that would be an oversimplification.
The issue is not who builds the applications, but whether they do so within a consistent architectural framework. In an enterprise environment, every application is part of a larger ecosystem – it must integrate with other systems, operate on shared data, and meet specific security and performance requirements.
Without this, even the best business initiatives lead to system fragmentation rather than simplification.
Low-Code in Enterprise Architecture – A Shift in Approach
More and more organizations are starting to view low-code not just as a tool for rapid application development, but as an element of system architecture. This is a subtle but critical shift.
The starting point is no longer a single application, but rather the data model, the integration approach, and the solution’s place within the broader IT landscape.
While citizen developers perform very well with simpler processes, more complex systems require proper support and oversight from professional engineers – ensuring that application development remains secure, consistent, and fully aligned with business efficiency.
In practice, this means building solutions based on standard integration mechanisms such as APIs, and considering scalability and performance from the outset. The platform must be capable of operating both in simple deployments and in complex environments supporting critical business processes.
What Differentiates Enterprise Low-Code from “Classic” Solutions
Not every low-code platform is prepared for such demands.
In enterprise environments, critical factors are often those that are not immediately visible: data management approaches, integration capabilities, support for team collaboration, deployment architecture (e.g., on-premises support), and the level of control over changes.
Performance at large data volumes and the ability to operate in both cloud and on-premises models are also essential.
Equally important is the transition from prototype to production. Organizations need solutions that enable iterative system development, testing changes across multiple environments, and deploying them in a controlled manner – without risking destabilization of the entire system.
archITekt – Low-Code Designed for Complex Systems
This is the approach behind the archITekt platform.
Rather than focusing solely on rapid application development, it has been designed as an environment that supports the creation and evolution of IT systems in large-scale organizations.
It enables integration with existing solutions via APIs, supports advanced integration mechanisms based on complex data structures from multiple sources, and allows for sophisticated data operations and transformations. It supports various deployment models – from on-premises installations to cloud environments – and scales alongside growing business needs.
As a result, organizations can move from prototype to production in a structured way, maintaining control over system architecture and security.
IT Democratization Needs Architecture
IT democratization represents a shift in how software is built. Organizations will increasingly delegate some capabilities to business users because the pace of change demands it.
The key question is not whether low-code will be used, but how.
When nearly everyone in a company can build applications, speed is no longer the only concern –control and consistency across the entire IT environment become critical. Without them, IT democratization can quickly shift from improving efficiency to deepening IT sprawl and informational chaos.
