Using low to no-code platforms offers benefits in terms of increased efficiency and rapid development, but it’s essential to recognize their limitations and use them only when appropriate. Here’s a brief overview of some downsides of using no-code and a scenario where it can add business value without compromising good software development practices.
Many low/no-code platforms have significantly evolved in recent years, offering advanced visual templates for comprehensive applications and data processing pipelines. Nevertheless, it’s important to note that most, if not all, of these tools lack certain critical features that become essential as a project matures beyond its initial stages.
Table of Contents
- The Need for Source Code Versioning and Transparency
- No-Code As A Complement
- An Example of No-Code Done Right
- Conclusion
The Need for Source Code Versioning and Transparency
Here are some of the pain points of no-code platforms:
- No source code versioning. Most of platforms abstract away from source code and make it inaccessible to developers. This presents a problem when trying to keep track of changes over time for the sake of visibility and troubleshooting.
- Lack of transparency. Transparency is synonymous with trust in the world of software development. Seasoned developers like to stay in control and understand how things work under the hood. When there is no access to source code it can lead to a perception that no-code is a makeshift solution awaiting to be replaced.
- Transition from no-code to code. Ideally, there is always an option to convert no-code solution into code when needed. This approach provides the flexibility to start quickly with a no-code solution. Eventually, there is a transition to a code-based solution with versioning, monitoring, and other development best practices.
There are more issues with low/no-code platforms, most of them revolve around limited control and a strong reliance on a particular provider. However, in this post I would like to emphasise the importance of having access to code.
No-Code As A Complement
The pattern of providing a visual builder, in addition to other tools, has become common with platforms that don’t primarily market themselves as no-code. For instance, platforms like Google’s GCP or Amazon’s AWS allow you to create a new instance of a web server through an interactive guide in a web console. Once you are satisfied with the outcome, you can programmatically define this and many other resources. The capability to automate a solution via writing code proves invaluable when you need to replicate the entire stack in a new environment leaving little space for human errors.
An Example of No-Code Done Right
Take Stripe as an example. As a developer, I absolutely love my experience with this payment automation platform. Their SDK is intuitive, available in several mainstream languages and well documented. In addition to the SDK, Stripe also offers no-code features. For instance, you can manually create a checkout page. This approach is not only smart but also tremendously useful.
Imagine a typical startup where developers are busy building “the next big thing”. At the same time though you need to enable billing to keep the business going. While the developers are tied up, a business owner or a salesperson can swiftly put together a simple pricing page and test different subscription plans for their market niche. When the time is right, a developer takes over using the robust features of the Stripe SDK, complemented by test automation and code versioning.
To me, this is a perfect showcase of the true value of no-code when it solves a business problem and eases the burden on the development team. More importantly, it enables the creation of an MVP that’s validated by end-users or customers. When a developer finally steps in, they craft code that’s purposeful and focused.
Conclusion
In summary, the value of no-code tools lies in their ability to empower non-technical users solve specific business problems quickly and with ease. However, for more complex projects the possibility to transition to code with versioning and monitoring is crucial. No-code and code solutions can complement each other effectively, and the choice between the two approaches depends on project requirements, priorities and timelines.