Applications of Low-code and No-Code Software Development Tools
Most of us agree that there is a continuum beginning at one extreme where everything must be coded manually line by line all the way through manual configuration of metadata via menus and wizards to complete automation of application builds using scripts for build management. At some point on this continuum are low-code and no-code development tools.
However, I would like to explore the difference between “low code” and “no code.” The point where these tools should be placed on the continuum isn’t always clear because there are different forms of both “low code” and “no code” tools available today. Some vendors want their product to fit in the middle of these two approaches so they talk about a hybrid approach, or market their tool as having higher functionality than true no-code but still lower than true low-code. It’s important for us to understand what each approach actually means when we consider whether it is appropriate for a particular business problem we’re trying to solve.
Everyone seems to agree that the end point of the continuum where everything is automated via scripts, plug-ins or other mechanisms is no-code application development. There are many low-code development tools that provide what I would consider to be true automation of specific tasks in an otherwise manual process. This typically includes wizards and some level of business rule assistance for common processes, but not complete automation using metadata, relational data sources and complex algorithms.
At the opposite end of the spectrum are true no-code development tools . These tools enable you to create a full application, including advanced calculations and reports, without writing code or scripting at any time during the creation process. You can simply drag and drop items onto screens as needed and connect those items with simple connectors such as “and”, “or” and “equals”. The final application is an executable that can be deployed to a Windows or web-based platform.
This article looks at some specific examples of how different types of low-code and no code tools are used in the creation of applications at organisations I’ve worked with recently. It also discusses whether these tools still require involvement by developers who know about integrating metadata, relational data sources, algorithms and other technical programming knowledge into the applications they create for others to use. These services can be provided by consultants or IT staff on staff.
Which approach is right for you? That depends on your organisation’s business processes , industry sector, company culture, existing development expertise (including future demand), budget and timelines . This discussion will help you determine which approach is right for your York organisation.
The Early Days of Automated Application Builds at a Large Capital Equipment Manufacturer
In the beginning, there was command line. Eventually, some scripting languages were used to automate the tasks performed during a build process using scripts that were executed in order on a predefined set of servers. The result was an application that had almost zero configuration and no customisation, but could be deployed quickly and reliably. This type of build process proved successful over time because it allowed developers who did know how to script to create applications from reusable components without involving IT professionals or requiring detailed input from business users. To use these new builds, all you needed were source files containing metadata about each component along with any other required data.
This approach worked great until the company grew and new business users wanted to deploy builds of their own. They didn’t want to wait for IT staff or developers who knew how to script every time they needed an application, so they started searching for easier ways to create their own applications without learning programming languages.
The first step was scripting away, which meant moving development processes into Microsoft Excel workbooks that could be saved as macros. These tools were more accessible than scripting but still required knowledge of VBA (Visual Basic for Applications) in order to access the metadata needed to build simple applications using reusable components. But it is important not only what you can do with these tools but also what you can’t do with them. What you can’t do is access metadata for each component to create rich user experiences with lots of configuration options. What you can do is create simple reports using the data available in these components, including some basic filters and sorts. If there are configuration options involved, they are typically hardcoded into the application which limits who can configure them while also creating challenges when changes need to be made.
The next step was light coding or no-code development. This new wave of tools allowed business users to drag and drop items onto screens where they wanted them without any knowledge of VBA, scripting languages or metadata required by traditional build processes. They could then connect items together using connectors that essentially amount to “and”, “or” and “equals”. Business users could even define their own fields and data types in a form, a feature typically provided by scripting tools. These new tools also came with pre-built dropdowns that could be customised to behave the way users needed them to produce reports that were easy to build.
In many cases, no coding is necessary because these applications can be deployed using customisation options which are limited in what they allow you to do but easy enough for most business users to handle without help . This approach worked well when each application was used by only one user or small groups of users who all needed the same look and feel (or “skin”). For organisations that had an IT staff or skilled developers who knew how to create different skins for different groups of users while maintaining the core functionality provided by reusable components, these tools still presented challenges.
The latest wave of low-code development tools have tackled this problem by allowing business users to customise applications without requiring any knowledge of coding . They do this by creating templates that are accessible through a web browser or mobile device. These templates contain core functionality once provided by traditional build processes and scripting/no-code development tools, such as forms and reports. Users can then add or remove fields from forms, add or remove tiles from home screens and change the layout on data entry screens using an interface similar to what you would see when configuring Salesforce for example. Before they make changes, users simply need to decide which template (or “skin”) they want an application use in order to alter its look and feel.
In addition to creating new applications from scratch, business users can make simple changes to existing applications without requiring a single line of code . For example, a Salesforce administrator could log in and configure the user interface by making simple changes to its configuration files. If there was a need to add a few more fields for account information, they could do so using configuration files instead of having to change the source code then redeploying that entire application.
What you can also do is create applications that behave differently for different subsets of users or even depending on where they are logged into your system from . In this situation, an app could load up forms populated with data relevant to each group of users see it. Data shared between apps could also be managed with custom logic. For example, a user logs into their CRM app and they are presented with the home screen that shows them only records owned by them (and no one else). If they then switch to their service management application and log in using the same credentials, it could load up the customer’s records based on an access level specified in their profile
If you find yourself wondering what will end up here when you click Publish, don’t worry because low-code development tools allow you to preview changes before publishing . This means developers can debug applications without creating any conflict between what is being worked on locally versus what is already live in production. You can also test it out within your company before making the application available to your customers.
What else can we do with this?
Low-code and no-code development tools allow us to build applications that help us more easily manage our simplest day-to-day tasks . We use them to add new fields on forms, create tiles and add dropdowns which can be used for filtering data on reports. For example, let’s say we wanted to add a new type of widget which is filtered by colour then displayed next to existing widgets based on their availability (so you could pick the one you like whether it was green, white or some other colour). Developers could solve this problem using traditional programming languages but at the cost of requiring someone more technical than most business users if they needed to make any changes in the future.
With these new tools, we can allow business users to add this widget themselves without writing any code. All they need is an understanding of the template used for displaying widgets and basic filtering. For example, it could be as easy as showing them a list of colours with checkboxes next to each so they can select which ones are available for use in their application. After that, all they would have to do is click save and the application updates itself dynamically.
No-code development tools provide us with other opportunities to improve how our organisations operate . Let’s say you own a marketing department that needs an application built for tracking leads. You might create your own or request that someone build it for you but nobody on your team has programming skills. Instead of being held up by the time it takes to find someone with programming skills, you can use a low-code development tool to quickly build an application that lets you input new leads through a form on your website . You can also create reports using preconfigured widgets which are easy for everyone to interact with.
Having access to more tools has helped us become more self-sufficient when it comes to what we do in our jobs day in and day out. However, that doesn’t mean there aren’t still some places where developers come in handy. For example, not having programming skills wouldn’t prepare anyone for creating complex integrations between applications or working with APIs . Nor would it be helpful if they were responsible for testing software before pushing it live.
That being said, these low-code and no-code development tools have greatly contributed to businesses becoming more efficient while minimising the need for technical resources.