Broken Promises of the Low-Code Approach
This is the first of a three-part series.
It’s easy to get swept up in the enthusiasm for low-code and no-code solutions (which I’ll refer to simply by low code), especially with their enticing promise of simplicity and user-friendly interfaces. They’ve been hailed as the answer to the IT skills gap, enabling non-technical users to create functional applications without having to write a single line of code. However, the actual effectiveness of these tools for your team can often be more of an illusion than a game-changer, particularly when scrutinized in the context of evolving programming trends and tools.
The Alluring Simplicity of Low Code
Low-code platforms have undeniable allure, especially for leaders yearning to unlock their teams’ speed and agility, enabling rapid application development. The need for extensive coding knowledge is eradicated, freeing up IT resources and democratizing the ability to contribute to application development. For small to medium businesses with limited IT resources, this can be a significant advantage.
Equally attractive is the cost-effectiveness of low-code solutions. By reducing reliance on experienced programmers, who are more costly and harder to retain, these platforms offer the potential to lower labor costs considerably. Additionally, many low-code platforms deliver built-in scalability, allowing applications to handle increased loads as user bases grow.
The Misunderstanding at the Heart of Low Code
The reality is that many low-code solutions present a fundamental misunderstanding of software development: They conflate the challenge of understanding a programming language’s syntax with the challenge of designing effective application logic. Programming languages are just tools; their syntax is merely a means of expressing solutions. The true heart of software development lies in problem-solving, in crafting algorithms, data structures and interfaces that efficiently fulfill the application’s needs.
By aiming to simplify software development through a graphical user interface (GUI), low-code solutions replace syntax without necessarily simplifying the fundamental challenge of designing robust applications. This approach can introduce multiple drawbacks while failing to alleviate the true complexities of software creation, ultimately having a negative impact on your team’s ability to deliver real value.
Other Pitfalls of Low-Code Solutions
Low-code solutions frequently grapple with limited customization, often failing to meet specific, complex or unique business requirements. The risk of vendor lock-in is another significant downside, potentially leaving users high and dry if there are changes in pricing, feature offerings or if the vendor closes shop. I’ve had first-hand experience with these events, and the result for the team is fairly catastrophic. They’re left with a severe skill gap and a lengthy period of low productivity.
There’s also the issue of performance and efficiency. Applications developed via low-code platforms may not perform or be as efficient as those crafted with traditional code, particularly for large, complex applications.
The promise of simplicity often leads to a reality of unexpected complexity. While low-code platforms shine at creating simple applications, they often fall short when tasked with more complex scenarios. This last challenge is typically exacerbated when the tools are used by those with less experience in developing complex systems.
Recent Trends Present an Alternate Approach
Given the challenges presented above, the value of low-code solutions further erodes with the continued proliferation of code libraries and frameworks for nearly every conceivable use case. Consider frameworks like Next.js and Nitric or platforms like Supabase and Vercel. These newer developer-focused tools are often more productive than their low-code equivalents and they certainly make the resulting applications far more future-proof.
These solutions take an alternate approach to boosting productivity. They streamline developers’ workflows and maintain the flexibility inherent in traditional coding instead of substituting niche low-code alternatives. This keeps the door open to customization, adaptability and complexity that low-code solutions often struggle to accommodate while allowing limited development teams to achieve more with less code.
Teams I’ve managed have generally been more enthusiastic about working with developer-focused frameworks and tools; they provide more enjoyable developer experiences with broader community support. This keeps the development team motivated to learn and expand a skillset that will serve their personal goals as well as the team’s goals.
Low-code solutions, while democratizing software development, come with their set of limitations and potential drawbacks. In some cases, a fundamental misunderstanding lies in equating programming syntax with the real challenges of software development: problem-solving and application design.
Moreover, the emergence of comprehensive code libraries and developer-friendly frameworks challenges the relevance of low-code tools. By empowering developers and streamlining their workflows while preserving flexibility, these modern solutions offer a more future-proof approach to software development.
We’d argue the goal should be less code, not low code, and our next post on this topic will discuss why and show how this can be done with new tools.
In the meantime, check out what we’re doing in the open source Nitric framework to reduce required code through automation.
The two approaches must undoubtedly coexist, serving different needs based on the project’s complexity and requirements. However, it’s critical to understand these nuances to effectively navigate the landscape of software development and harness the appropriate tool in each situation.