Getting Started With Low-Code Development

In 2014, Forrester coined the term "low code" to describe development platforms that "accelerated application delivery, reducing the amount of hand-coding required." Low-code platforms employ visual, declarative techniques instead of traditional lines of programming, are used by both developers and non-developers, and significantly reduce the time and effort to deliver applications and automated processes.

However, despite the definition, low code still means many things to different people as several tool types exist under this umbrella term: website generators, form builders, API connectors, database builders, workflow automation, and more.

Each of these tools targets different domains and requires varying technical proficiency levels. The only common theme is that they have a graphical user interface that enables application users to configure and adapt solutions to exact requirements.

A low-code development platform typically contains:

• Visual integrated development environment (IDE) – a drag-and-drop interface where developers can build an application's UI, workflows, and data models
• Connectors for back ends and services – integrate data and logic from data sources and services
• Reusable components – pre-built, pre-tested drag-and-drop modules and functionality
• An application manager – tools to build, debug, deploy, and maintain the final applications

One of the most prominent reasons for the rise of the low-code model is faster deliverability and quicker innovation. In addition, it enables anyone in the organization to build apps — even those with limited technical knowledge or development experience. Its primary benefit of rapid development can lower costs, increase delivery speed, and provide greater accessibility.

Is Low Code New?

Low-code development platforms trace their roots back to Fourth-Generation Programming Language (4GL), a concept developed from the 1970s through the 1990s. The language introduced some of the most popular Rapid Application Development (RAD) tools, such as Clarion, Microsoft Access, and Powerbuilder, putting development-like capabilities into the hands of business users with non-technical backgrounds.

Modern low-code development platforms take the evolution forward. These platforms visualize computing or domain concepts and have added the underlying infrastructure to support them. But perhaps most importantly, they have removed any friction between building and running the final application.

Is Low Code the Same as No Code?

The simple answer is no. While both platforms rely on the same visual drag-and-drop development principles, no-code platforms abstract code, whereas low-code platforms have retained some ability to add code manually when required.

To a large degree, no-code apps are rarely complex, sticking to a specific domain and functionality. These tools predominantly require the user to configure solutions and have definite limits on what can be accomplished. As a result, they often need further development to integrate and connect to multiple services or add custom functionality.

Low-code development platforms bridge the gap between the inherent limitations of off-the-shelf software, the rigidity of no code, and the high costs of developing custom applications from the ground up. The most popular use cases are:

• Business process applications – One of the chief targets of low-code platforms is business process management (BPM), allowing the user to build apps that automate processes and handle them more productively. 
• Database management applications – Using a low-code platform to bind, view, update, and visualize database tables. With most of the popular database formats supported, developers can easily tie business logic to the occurrence of various events that get fired during data management.
• Omni-channel platforms – These requirements need the application to fetch data from multiple sources (databases, APIs, custom business logic, files, and cloud services) and automatically provide real-time visibility. 
• Microservices-based applications – Using low code to accelerate the development and easy maintenance of independent, scalable services.
• Modernizing legacy applications – Building APIs to modernize, extend, and enhance existing systems with new functionality.

Who Uses Low Code?

When we talk about application development, we usually think of apps built by experienced developers. Traditionally, this is the case. However, low-code platforms have ushered in a new era of citizen developers, bridging business and IT and filling the gap between software demand and developer shortage.

The citizen is a user without formal software development training but can build applications using low-code platforms. Being much closer to products, domain-specific processes, and customers, they are ideally placed to recognize the immediate business needs, act as a solution designer, and implement a solution without IT involvement.

Other different development paradigms exist too. For example, some low-code platforms target developers and enable rapid development, integration, and automation. Others target software development professionals and citizen developers with tools to collaborate and develop applications. Regardless of the user type, the goal remains: to accelerate development across the organization.

Besides the obvious advantages of speed, cost, and ease of use, low code helps citizen developers:

• Speed up the development of solutions that solve critical challenges within the organization
• Empower users who understand the opportunities of a new app
• Improve overall business productivity without replacing undue impact on IT

Many platforms also include deeper technical capabilities to support the professional developer and the traditional software development lifecycle. A good development platform accelerates the mundane, repeatable aspects of software development, allowing developers to focus more on solving the unique requirements of the application's logic that require time, attention, and expertise to succeed.

By doing so, they provide significant advantages over traditional code within the IT function to:

• Shorten the software development lifecycle
• Apply consistent code quality and lower the maintenance burden
• Improve efficiency and agility amongst and across teams 
• Provide a more straightforward path to complex topics such as security, infrastructure, and scalability of applications

Selecting a Platform

A low-code platform's toolbox includes an array of pre-built components with well-defined functionality within its specialist domain. However, when selecting a platform, the buyer should take into account the following considerations.

Identifying the Current and Future Use Case 

Consider your current tools, systems, and services. Can the platform solve your immediate problem and accelerate application development across the entire organization?

Specifying the User Who Will Develop Applications

Low code still requires some coding skills to build applications. Understanding who will design, develop, and maintain the apps is critical in matching the use case and the user's capabilities.

Integration Requirements

Nearly all platforms offer APIs, and many vendors provide pre-built integrations, which are great for working with major third-party vendors. However, what you can do with the APIs, how well they perform, and how they are supported vary considerably. Therefore, serious buyers should take caution to examine the platform's extensibility beyond the point-and-click connector.

Cross-Platform Support

Most businesses prefer a cross-platform development framework to develop solutions for web, mobile, and other platforms. This should automatically happen behind the scenes with no extra effort, coding, or resources.

Hosting

Low code was once synonymous with SaaS, but the modern vendor allows for greater flexibility. For example, many enterprises don't let their data or application designs leave their carefully controlled networks, whether for compliance or other regulations. As a result, knowing where and how you will host your application is often just as nuanced as building it, and should not be overlooked or taken lightly.

While low code offers several out-of-the-box services to assemble an application without writing code, there is a growing need for more sophisticated features to support the developer mindset and modern IT.

Working With Data

Most low-code platforms are extensible, providing direct integrations with major vendors and enabling IT to turn APIs, web services, and command lines into reusable building blocks. In addition, these out-of-the-box integrations will let you connect to external APIs, allowing easy use and management of authentication tokens, retrieval of data, and some level of query parameterization.

Outside of standard connectors, the developer is often faced with several nuances such as authentication, data validation, and error handling, sometimes making integration to a particular technology so complex that it can diminish the critical benefits of low-code development. Therefore, knowing if the platform supports industry-standard interfaces and protocols (e.g., REST, JDBC, OData), or whether it is open and extensible with custom code and APIs, will significantly influence adoption within larger development teams.

Customization and Complexity

One of the past criticisms of low-code development has been the perceived limitation on the types of apps it can deliver. In the past, many "solution or vertical-niche" platforms were centered solely around common business problems, concepts, or industries (e.g., workflows, BPM), which created a perception amongst IT teams around the lack of flexibility and the inability to provide the additional functionality that they would want or need.

However, as the role of the software developer and technology advances, so has the modern low-code platform. But customization options still vary widely from platform to platform. Some are proprietary "black boxes" that hide the code; some are open-source and provide access to the underlying code. Others offer the capability to supplement the generated code with additional custom code.

Before adopting any platform, it's essential to know how easy it is for developers to bring any external innovations into the low-code platform. Having the capability to build applications quickly while balancing the requirement for more complex functionality is a fundamental factor in developer adoption. To deliver fully customizable applications, developers demand a pro-code-like experience where they can quickly implement complexity in their solutions, accommodate for edge cases, or integrate unique solutions into even the most complicated technology stack.

Enterprise Development

For adoption in the enterprise environment, the developer may need to consider a deeper feature set related to their particular circumstances, including how the platform approaches asset reuse, scalability, DevOps, and compliance and security.

Reuse

The reusability of assets is a crucial driver of productivity among IT teams. A good low-code platform should allow users to re-use pre-configured modules, core functions, code snippets, and back-end integrators to build different applications swiftly.

Scalability

Low-code solutions should allow scaling for both usage in the environment and your application. For instance, you may have the infrastructure capacity to develop and deploy apps, but your license terms may restrict it, and vice versa. So when setting up, find out the platform's capacity and determine if it suits your scalability needs.

A genuinely scalable low-code platform has well-defined REST APIs that separate the UI from the back-end layers, allowing for developing applications at scale and ensuring that the key practices in terms of performance and design are followed as per industry standards. Ideally, the low-code platform must have fast API creation and binding tools with automated API documentation to help you re-architect your monolithic, legacy applications to modern, microservices-based micro-apps.

DevOps

A sophisticated low-code platform should integrate and support the capabilities of an Agile development process. When it comes to DevOps capabilities, consider:

• Versioning applications or integrating with a version control system such as GitHub
• Working across the development lifecycle (dev, test, and other environments)
• Ability to connect to tools that manage backlogs and roadmaps
• Integrating with continuous integration, change management processes, etc.
• Tools and other specific functionality to support disaster recovery and data sciences

Compliance and Security

While citizen developers often do not have the experience or understanding of security implications, it's a critical step for enterprise developers. Relying on your internal security team to evaluate the platform before purchase should be considered best practice. An expert is best placed to understand how the platform can accommodate role-based administration, data masking, and other considerations, such as HIPAA compliance, hosting constraints, or other security-related limitations.

Low-code apps may be fast to build, but they should still be built with industry-standard practices in mind. In this section are guidelines for how to succeed in low-code tool selection and implementation.

1. Platform Selection

With countless vendors in the space, it can be challenging for companies to know where to start in the selection process. The ideal strategy should be to let traditional IT help choose the platform, following the same process for any other technical tool or system they have put into production. This means taking a deep dive into testing the platform's capability, guiding its use, educating users, ensuring it fits into the organization's architecture plans, has a maintenance plan and retirement strategy, etc.

2. Planning Your First Solution

Start with a roadmap. It might be stating the obvious, but it helps focus on the organization's immediate needs. What are the requirements? What kind of applications do you need? Who will build it? Lay out the scope for deployable technologies to determine the standards for data security, testing, ownership rules, etc. A large part of implementing a low-code platform is understanding your own needs, both now and in the future.

3. Integration

Take time to understand how the platform will connect with an increasingly complex tech stack that can include distributed systems, legacy applications, third-party APIs, off-the-shelf software, and more. In addition, data integration, the variety of data formats, and different types of endpoints found in the modern organization can be complex and a barrier to speed, especially in a large IT environment.

4. Build

When it comes to building your application, it doesn't matter whether you are a seasoned engineer or a citizen developer — there is still an unavoidable learning curve. For the best results, start with a small application, build confidence in the toolset, and engage in an Agile mindset. Encourage the fail-fast mentality with quick prototyping, rapid feedback, and reiterations.

5. Testing

As low-code programming minimizes the time and effort it takes to write an application, you might be tempted to think it reduces the time QA teams have to spend testing the application. However, functional testing and performance testing for low-code apps are just as critical as for any other type of app. In fact, in some ways, having a solid QA process in place for low-code environments is even more critical than it is for conventional apps as they more often than not form part of larger workflows that must integrate with external data resources.

6. Deployment

One immediate benefit of low code is the speed of deployment — often with one click. But with so many options — public, private, hybrid clouds, and on-premises — there is still a considerable need for developer-type skills to manage the infrastructure and architectural nuances of getting your application into production. Take careful note of how you do this to eliminate the addition of excess technical debt associated with managing, validating, and scaling apps as they grow.

With the inherent benefits of tackling the constraint of cost, scope, and time, low-code platforms appear to be in it for the long haul. The business case for low code keeps building while the unfounded fears that it can't meet enterprises' needs, or that they are going to replace human coders, continue to fall in the face of data to the contrary.

Low code can be tempting if your IT organization is overstretched or unable to meet your delivery times. However, the key to adoption is to start small while building up the organization's capabilities and skills. The low-code approach is simple enough for beginners to build high-value apps — and sophisticated enough to meet the needs of professional developers tackling complex challenges.

While these platforms might not possess all the answers to every development challenge, they have simplified and shortened several software development stages. So whether it's that throwaway prototype, a proof of concept, or that business-critical management system, low code has high potential to arm the modern business with agility and innovation.