Low-code platforms and tools are transforming application development in organizations of all sizes. These tools provide visual development environments for professional developers that accelerate and streamline their work, while also making it easier to collaborate with business stakeholders.
A separate category of tools has also come to market – no-code tools – that specifically met the needs of such ‘citizen developers,’ empowering them to build a range of different types of business applications without the need for professional application development skills.
Want to learn more about what is a citizen developer and how to govern them? Check out this article.
However, no-code and low-code capabilities are converging. Many of today’s low-code tools are adding no-code features, making them simple enough for non-technical business users to work with. And while modern no-code tools focus on the creation of relatively simple, departmental-level apps, the vendors of these tools are adding increasingly sophisticated capabilities to them as well for those ‘power users’ who are able to leverage such capabilities.
In spite of this convergence, however, don’t confuse the two: low-code tools address the needs of professional developers while no-code tools focus on citizen developers, who approach application creation differently from their more technical colleagues.
For those organizations whose appdev teams have achieved notable success with low-code, the question still remains: is there a role for no-code in their organizations? The answer might surprise you.
Who Wants No-Code?
This question is moot, of course, if nobody wants no-code in an organization that has achieved success with low-code. For many organizations, however, line-of-business users and their leadership still desire no-code tools. The reason: empowerment.
Regardless of how fast or efficiently the appdev team works, business users may still have application requirements that they are more comfortable satisfying themselves without calling upon the pros.
Perhaps requirements for such applications evolve quickly. In other situations, regular interactions with stakeholders – who are typically other employees – take place on an informal, regular basis.
In contrast, asking the appdev team to handle such a straightforward, employee-facing app raises its level of formality in terms of interactions between stakeholders and developers. In some cases, such formality is welcome, while in others, it is overkill.
When an organization has a backlog – that is, a list of required applications that the appdev team hasn’t gotten around to yet – this citizen developer empowerment benefit of no-code can be especially strong.
Remember: the most efficient way for the appdev team to approach their backlog is by prioritizing it – conducting a sort of application triage that devotes resources to those applications with the highest business value relative to the time investment necessary to deliver the application.
Such a triage approach, however, isn’t necessarily ‘first come, first served’ – and thus some lower-priority applications might languish in the backlog for an unacceptably long time.
The root of this problem is the fact that how one person might prioritize the backlog is likely to be different to the way another person might. A particular app may have relatively low value to the organization because it might only serve a single department, for example. But for the people in that department, it might have a high priority.
Why IT Should Support the No-Code Citizen Development Initiative
The first reaction among IT leadership (including appdev management) might be that no-code would be a redundant addition to an already successful low-code effort – one that would add cost and governance complexity to the application development process.
Such a reaction, however, would be premature. In reality, the citizen development and low-code efforts should ideally work hand-in-hand.
Cross-organizational discussions can quickly divvy up existing application backlog, resolving it more quickly now that more people are tackling it.
In addition, the collaboration between citizen development groups and IT can bring critical governance to the line-of-business efforts. After all, nobody wants a return to the Lotus Notes days, where business users created apps willy-nilly, leading to the shadow IT problems of low quality, redundant capabilities, compliance breaches, and security holes.
Low-code/no-code collaboration can give lines of business the best of both worlds – the user empowerment and immediacy of citizen development, combined with the governance, security, scalability, and quality of professionally developed applications.
Organizations who are successful with their low-code efforts are also able to achieve these governance priorities in the absence of no-code as well. However, shadow IT can rear its ugly head at any time, as all it takes is one business user deciding to build an app for their company without consulting the IT organization.
In contrast, for organizations with strong no-code and low-code efforts working in tandem, there is little to no motivation to create such off-the-radar apps.
The Intellyx Take
Some professional developers (or their managers) may still be uncomfortable with the idea of no-code working alongside low-code. If you’re one of them, think hard about why you’re uncomfortable, and it likely has to do with control.
It’s not that the appdev team is selfish. Rather, they understand that adding people to the appdev role increases the threat surface for all of the organization’s technology. Better to keep the apps on a tight leash than risk a compliance or security breach, right?
Not so fast. Such thinking is part of a hierarchical, top-down approach to management that presumes that the people higher on the totem pole know better than those below them.
Many years of appdev experience have shown, however, that this approach is upside down. Modern software development techniques like Agile and DevOps call for flattening the hierarchy, pushing decision making down to the individuals on the teams.
The reasoning for this flip is straightforward: the people with their hands on the software are professionals that know best about how to solve the problems facing them. It is the role of management to give them the resources they need and then get out of their way.
Among the management-provided resources that are essential to successful application creation is sufficient governance to provide the guardrails that keep everyone aligned with the security, compliance, and appdev best practices that are important to the organization as a whole – without slowing people down or disempowering them.
Allowing lines of business to bring no-code into their organizations is an example of empowering people on the front lines to make decisions for themselves. Proper coordination between those no-code efforts and the low-code efforts of the appdev team gives everyone the guardrails they need to meet the needs of the enterprise.
© Intellyx LLC. OutSystems is an Intellyx customer. Intellyx retains final editorial control of this article.