When Microsoft Visual Basic debuted, it promised to take programming to non-programmers via drag-and-drop fields for forms and data controls. Decades later, low- and no-code systems take that promise to the next level, where they can possibly generate the form and even the database -- no developer experience required.
But these platforms also create unique software quality challenges, such as requirements and risk management, as well as how to test or deploy code that a developer didn't write. While these tasks might not be easy, the right tool for the job can mitigate a lot of the hassle -- and there are different no- and low-code techniques to fit the bill.
Modern low- and no-code techniques
With low-code and no-code platforms, there are generally three common -- and more efficient -- ways to build apps.
For one, some low-code platforms have a form editor with which you drag and drop fields for what it assumes is a create, read, update and delete (CRUD) application. The platform likely takes the form and creates the database for the CRUD app.
In another low-code technique, you model the data, and the platform generates the screen. Multiscreen applications need a workflow, which you can also design in a flowchart. With this model-driven approach, the program runs through a compiler that takes the flowchart and generates the user interface.
The third way involves no-code platforms. This method illustrates the unique ways these platforms deploy applications. With traditional apps, users download an application and update it as new versions roll out. For SaaS, the vendor hosts the software via a web server and typically also hosts an environment to test it in.
No-code platforms don't work that way. Such environments eliminate the need to register a domain, create test and production servers and find a process to move code from place to place. Instead, you simply edit the model and publish. It's that easy. On top of that, the platform might provide prebuilt templates for common application tasks, such as invoicing, expenses and time card tracking. In essence, you start with an open source-like project that is easy to edit and comes 95% done -- just add your custom requirements.
That head start saves the user a great deal of time, but it creates a test problem: Production is the only environment, and everything else in the application development process exists as a model. While a few complex tools offer the possibility of a test stage between model and production, those tend to cost more and be designed for use only on the larger deploys with more moving parts, not typical internal business processes that get converted into an application.
Use cases for low or no code
No-code applications often lack the functionality for special cases. For example, a programmer can write form-field validation that makes sure the program properly formats an email address or phone number. Instead of writing validation logic, the no-code tool has the database record types or fields called phone number and email address. This tabulation works until you have a custom validation, such as driver's license number, or a complex validation like three out of these four fields must be filled in. With low-code platforms, the app creator can add to the model. But for no-code platforms, assume you're stuck with a model -- and garbage models can only create garbage apps.
Low- or no-code apps are a good fit for single, isolated business process that users can replace if something goes wrong. In this case, an analyst or the intended user creates the app. If it's employees who will use this software, it doesn't need to be beautiful. The tools can enable multiuser and remote work scenarios, as they can place the database on the web or on a mobile device -- albeit with separate login and authentication.
Another no-code use case is the short-term website, created for a public event or conference, for example. A no-code platform's prebuilt templates make setup easy. With the model-driven approach, an organization can create a mobile application generated out of the model and manage the application delivery process. Then, instead of creating an application image and uploading it to a digital store for download, users log in to the application, which runs the latest version of the no-code app.
Let's talk about risk
With no-code software, version control likely only includes, if anything, a simple undo/redo option to go along with a publish button. The low-code tool vendor typically retains your database. If the vendor goes out of business, or you decide to change tool providers, it is not a sure thing that you will be able to export that stored data. Some low-code tools enable data import/export, so you can provide the spreadsheets that you want to upsize into applications and also pull them out.
If you've left spreadsheets and databases behind when creating a workflow application with a no-code tool, think of it as an iterative software project. You'll want a list of requirements, but your use of the tool will help define those requirements. You might realize you need form validation two weeks into the work, for example. This actuality means that the tool might capably perform 95% of the app build that you need, but that remaining 5% is an undertaking fraught with risk. Think about what would happen if you publish a bug. In many cases, the only choice is to roll forward and make the fix, as opposed to roll back to the last-known good state of the application. With model-driven platforms, which might only have a publish button and no way to preview or undo, the changes push right to production.
There are full-featured platforms that include a test environment, which can interact with microservices and use a company's internal authentication engine. Those environments come with higher prices and more platform lock-in than the more basic ones. Full-featured options also involve writing code, business requirements, change control, coordination between departments and all the other aspects of traditional, custom software. You might even call them less code, instead of low code.
These no- and low-code techniques form a continuum: no code for small, independent, replaceable systems and varying degrees of low code for projects that are more complex or customer-facing. It's good to have choices.