Web-based programming has come a long way from the days of HTML in the early 1990s. The citizen developer had to understand formal structure and syntax Now, a young kid, even an intelligent toddler, can open a web browser and code their heart out, creating visually stunning games and applications (sort of). The barrier to building software can be pretty low under certain conditions. The critical phrase is certain conditions.
Low-code, no-code programming is a development approach enabling everyday users to create software applications using highly visual interfaces. The developer can configure the user experience versus being required to use programming intense languages by dragging and dropping objects onto a canvas and then configuring relationships among the objects. For the simple application, users can often get away with modifying a few fields to respond appropriately to a required action. But is the low code, no code development paradigm that easy for anyone with a PC to create the next big software platform? Not quite.
The Low-Code Approach
With the low-code approach, a software developer can’t simply create a visually appealing layout and call it a day. The developer must drop objects onto a canvas and relate each object to an action (i.e., code). The relationship could be that five fields might have data, but where is that data stored? In a data repository or file of course, that must be configured. These configurations don’t automatically associate; the developer must create the association through a handshake between objects.
What happens when the developer decides the action is complete? Do you press a button, and nothing happens? Not at all. Like in physics, for every action, there is a reaction. The reaction is either a data output or a secondary screen. A developer must configure the symbiotic relationship between the field, button, or a combination of objects.
Leading software vendors offer low-code technologies that enable visual objects to be dropped on a visual canvas enough to establish the “code essentials.” It is up to the developer to reach the last mile, to bring the piece parts together. Reaching the last mile requires a lot of logical planning and user experience design preparation.
Connecting the Low Code Dots
When developing a low-code application, the developer must define each process they want to automate. For example, a home screen might be a dashboard with three forms and two reports. It is up to the developer to realize how many secondary screens are required to fully engage with the data. The developer must also decide what happens after you get to that secondary page. Is there more to be done, or is it a matter of configuring essential controls such as Browse, Back, Delete, Add, Refresh, and Save?
In a low code environment, you’d drag the button or image to the canvas and position the object per specification. That’s where the low or no-code interaction ends. You still need to configure via code each interactive element. And this is where code complexity may overwhelm the novice low-code developer.
Using the example below, you’ll see common application user experience elements clearly defined. Furthermore, a data source input produces a grid-like experience for the user to review. The programmatic activity is between the six form fields and the highlighted square area. Each time an input changes in the data entry fields with this pricing calculator, the results in the highlighted box also change. That’s the mathematical logic a developer must implement, an activity that cannot be completed through simple drag and drop.
Think It Through Before You Code
Logic must be applied to consume readable data, collect and process data inputs, or harmonize with other applications. Dragging and dropping of objects cannot and will not masterfully achieve run-ready applications without applying the human touch. Therefore, a low-code application developer cannot and should not immediately dive into the code abyss.
A bit of planning (aka thinking out loud) and strategy must go into development before the first object is planted on the canvas. No one should even think of writing a line of code until an architecture and design specification is established, at a minimum.
Here’s how to think it through:
- Define Your Application Purpose: What data source(s) will your application consume? Also, determine if the application is meant for data entry exclusively.
- Create an Application-Based Information Architecture: Treat your application like a website. You’ll have a home screen, and then below the home screen are functional areas with targeted interactions. Each functional action has a specific purpose. For each of those screens, define the interactions required. What you are doing in this step is taking an application content inventory coupled with identifying repeatable processes.
- Craft a Common User Experience: Could you imagine creating a series of application interfaces that do not look alike? The analogy I often use is that the Google Search Page is day and night from the Amazon e-Commerce Homepage. You need to find a common interface design for users to successfully interact with the application, with memorability, findability, learnability, and usefulness in mind. If possible, apply as many usability heuristic principles, as defined by Jakob Nielsen to your low-code application design.
- Prototype Each Application Sections Core Functions. Let’s assume you have four forms and a reports section. In this application, each form should also allow a user to search previous data entries and perhaps modify or delete those data entries. In that case, you’d be required to, at a minimum, create four interfaces: Home, Add, Edit, and Browse. Common buttons or graphics interactions will be applied across all four interface screens. The interface, though, should not vary. It should remain consistent.
Prototyping allows a developer to work all the functional and technical nuances out. Once each interface is ready for coding, it should take a short time for a user to tie objects together using code snippets and limited programmatic logic, hence the beauty of the low-code platform.
The above process should get you about 80% of the way to the finish line without an ounce of code. This portion of the effort is generally where you spend most of your time, not under the hood creating code interactions.
Rinse, Repeat, Reuse
Of all the low-code platforms, the ones that have gained the most significant adoption include tools by Microsoft (PowerApps), Salesforce (Lightning Platform), Google (Appmaker), Appian Corporation, and UiPath. Each platform shares common principles on application strategy and design prior to coding.
An experienced developer can easily shift gears from one environment to the next without learning an entire platform from scratch; it should be as easy as rinse, repeat, and reuse. One person, maybe two, can easily accomplish in days or weeks what would have taken an army of programmers months to accomplish even five short years ago. That shows how far we’ve come thanks to modern innovation.