What is low-code? In a nutshell, low-code is a way to visually model, design, develop, and deploy software fast and with minimal hand-coding. Though not “named” low-code until 2014 by analyst firm Forrester, visual development-based tools have been on the market for nearly two decades.

In practical terms, imagine coding new software applications not through line-by-line hand-coding, but by selecting pre-written, visual modules of code and dropping them into a workflow. Obviously, there are instances where you need to build custom code — and you can do that easily — but for the 90 percent of hand-coding that is repetitive, low-code lets you drag-and-drop functionality, saving you time, money, and the hassle of debugging software you’ve written dozens of time before.

It enables skilled people (both professional developers and citizen developers) to deliver value more quickly and more reliably. Developers skip all the infrastructure and re-implementation of patterns that can bog them down and go straight to the unique 10% of an application.

Perhaps a more appropriate name, although much more wordy, is “low-hand-code.” The end-result still basically has the same amount of coding as a program built using traditional methods. But the actual developer-hours that it takes to build an app using low-code, is much less.

So, there’s one answer to, “What is low-code?”

In software development, we rely on libraries, APIs, and third-party infrastructure to deliver the features and functionality that make our apps unique. But even with the addition of OPLP (Other People’s Licensed Property), we still get bogged down.

IT teams and roles have become even more complex and specialized; even full-stack developers have their specialties. Take a look atStack Overflow’s developer survey: self-professed full-stack developers responded that they specialized in C# (34%), PHP (30%), Java (45%), Node.js (49%), or other niches. Then there are the DBAs, the test engineers, the Angular/React/Ember specialists.

An interesting side note: C# was initially approved in 2006, yet only 31% of Stack Overflow’s respondents say they’ve been coding since C# was released. Talk about a skills shortage.

Much of the software we build follows similar patterns: an HR system and a ticketing system are both CRUD (create, reuse, update and delete) applications, for example. And of course, they’re not the only HR or ticketing systems the world has seen. If we’re being generous, perhaps 10 percent of each is unique; the rest re-implement patterns seen a thousand times elsewhere.

Low-code helps developers avoid locking themselves into being the designated person who knows “x.” It lets you skip the plumbing and re-implementation and go straight to the unique 10 percent. Common code elements, workflows, and business processes are componentized so you can drag them around and drop them into a visual environment. Application deployment, updates, and generation are automated.

Ultimately, low-code offers a way for developers to get more done. Spend more time creating and less time spinning wheels. Sure, it’s fun to learn the latest faddish JavaScript framework or play with a cutting-edge NoSQL data store, but while you’re doing that, your practicing low-code competitor has an MVP in front of customers.

So, low-code isn’t about reducing your value as a developer or preventing you from getting hands-on experience with 4GL. Instead, it lets teams of developers produce more value more quickly while drawing on their understanding of how to create and maintain high-quality enterprise, mobile, and web applications. Therefore, a low-code development platform can be a developer’s or development team’s best friend.

One of the past criticisms of low-code development has been the perceived limitation on the types of apps it can deliver. Early low-code platforms did, as most new solutions do, go after the low-hanging fruit. In this case, web applications and portals. A few years later, they went after mobile apps.

For those use-cases, low-code was a tremendous help in designing apps, particularly for those built using a REST or SOAP backend often used for both the mobile and web versions.

But low-code has grown beyond its humble roots and can now tackle projects as big as digital transformation, digital modernization, or legacy modernization efforts that can even involve completely replacing core systems.

In theOutSystems 2018 State of Application Development report, respondents offered the following insight into how they were using low-code in their own organizations. Note that respondents were able to select multiple project types, and these were the top five:

1. Customer or partner-facing portals and web applications
2. Employee-facing portals and web applications
3. Customer or partner-facing mobile apps
4. Extending or replacing legacy systems
5. Employee-facing mobile apps

If the high bar for a low-code platform’s extensibility is core systems modernization, then the next question is whether low-code can meet the CIO or CTO’s decision to tackle modernization in a DIY fashion (rearchitect or replace) rather than purchasing a new, off-the-shelf solution.

The short answer to both, “Can I use low-code to rearchitect my existing core systems?” and, “Can I use low-code to rebuild my existing core systems” is, “It depends.”

And it does. Low-code platforms vary wildly in terms of capabilities, scalability, and support. For those interested in learning more about the 80+ vendors currently claiming low-code capabilities, we would suggest starting withGartner’s Magic Quadrant for Enterprise High-Productivity Applications Platform as a Service (hpaPaaS) report.

Low-code is a solution to the inefficiency and slow speed of traditional application development. Advances like code modules that you can drag-and-drop rather than typing out, automated error checking, one-click deployment, and real-time performance analytics don’t replace what professional developers do every day. Instead, these advances make developers’ jobs less reliant on specific expertise, reduces errors, and significantly increases the rate of development and delivery.

As the move to “everything needs an app” grows, so do the pressures on IT to develop more and more apps to serve customers, partners, and the enterprise. These pressures and demands create a tremendous backlog on IT teams already pushed to the limits, both in terms of time and skills development. Luckily, necessity breeds invention, and in this case, the invention is the low-code development platform, and citizen developers are a not unwelcome beneficial offshoot of it.

Citizen Developers and Why They Are Important

If a low-code platform exists to simplify development, testing, and delivery processes, then it stands to reason that it shouldn’t take a veteran developer to use the platform. The term citizen developer is often used to describe someone who doesn’t necessarily sit with the dev team of an organization, but who has the chops necessary to see the need for a business-enhancing app and develop it with at least a tentative OK from the official IT team.

As usual, Gartner puts a more technical spin to the definition of Citizen Developer:

"A citizen developer is a non-professional developer who builds applications for use by other people. Although they do not report directly to IT, they use tools such as low-code platforms that are sanctioned by IT. This oversight by IT distinguishes citizen development from so-called ‘shadow IT,’ which takes place without the knowledge or control of IT."

Think of citizen developers as the registered nurses of the development world. They can do most of the things that professional developers (doctors) do, but before they turn anyone loose, a fully-sanctioned IT professional (the doctor) still has to sign off on the finished product (the patient’s treatment).

Citizen developers are filling a growing need in the IT world that’s being left by legacy developers who are either moving out of development due to career growth or retirement and also filling the gap created by the need for growing specialized skills like UI development and containers. Organizations are being asked to do more with less, and that doesn’t lend itself well to staffing a cadre of niche developers with specialized skill sets. The “jack-of-all-trades” is becoming much more attractive given the right tools — like low-code — to work with.

A low-code development platform brings computers closer to the ways humans think about problems. Think of the tools you use to build software. There’s an IDE, a data store, third-party APIs, at least one development language and, most likely, a framework of one variety or another. Your entire stack — from backend to front-end — has multiple moving parts. And each has a unique learning curve and specific integration needs.

Now, what about deploying and managing applications in production? Think continuous integration, issue tracking, schema migration, monitoring, security, and scaling.

A low-code development platform bundles together all those components into a single coherent suite of tools that lets you build applications visually. Once established, it then handles the full lifecycle of those applications through test, production, and ongoing maintenance. The most sophisticated low-code technology even takes care of dependency tracking; you get immediate feedback on how each change you made affects the full stack of the application.

Low-code platforms vary in size and complexity, but depending on the platform, you should expect to find everything you’re used to in a web or mobile app development environment. Here are some essentials you’ll find in all of them:

Visual development: An IDE for visually defining the UI, workflows, and data models of your application and, where necessary, adding handwritten code, is a vital component of a low-code platform.

Reusable components: Building snippets of visual code and saving them for reuse later is one of the simplest ways to “build once, deploy forever.” As with other popular developer tools, a low-code platform should simplify the development, storage, and re-access of code snippets to help you ensure code consistency and increase efficiencies across multiple development projects.

Automated database integration: The platform transparently converts your data models into relational tables and SQL queries. Pre-built connectors to a wide variety of databases and legacy technologies make connecting with your existing data easy.

Full lifecycle management: Low-code development platforms ease the headaches of deployment, maintenance, and change with a variety of options. Automated tools build, debug, deploy, and maintain the application in test, staging, and production. The best low-code development platforms, however, go one step further and offer one-click deployment, automatic scaling, and project management tools.

A day in the life of a low-code platform user is not unlike that of a professional developer in a traditional, full-stack role. But consider what your day would be like if you could take many of the “I wish I could’s” and “I wish I didn’t have to’s” you encounter daily and make them your reality. Likely, you would spend less time on things you dislike doing and more time on things you enjoy doing.

That’s what it’s like using a good, low-code platform.

Low-Code Application Development Starts Out Visual

As a low-coder, you spend your time in a visual development environment equivalent to Visual Studio or NetBeans. Rather than starting a project by hand-coding, some basic routing, or writing a set of failing tests, you draw the shape of your application in four parts:

Data models: Here, you specify the data your application will store and how it will be stored in the database. Some low-code development platforms allow you to pull in existing data models from an external database, such as SQL Server or Oracle. These platforms are well-suited for building enterprise-grade applications.

External data: Integrate third-party resources with your application, such as REST APIs or your company’s SAP.

Business logic: What is the precise workflow the application needs to follow in each possible scenario? This is the equivalent of writing methods in C# or Java.

User interface: The front-end, whether mobile or web, presented to the user. For mobile, depending on the platform, you can draw the UI, and it will produce a native cross-platform experience for Android, iOS, and Windows.

As you can see, it bears a striking similarity to the MVC model of development. Here is the big difference though. In a low-code development platform, you describe what you want to happen rather than prescribing the steps the computer should take.

Think of it like this: in C# or Java, your code gives the computer precise instructions for what to do. In SQL, your code describes what data you want to retrieve, but it doesn’t tell the database how to get it for you. SQL is declarative programming and so is the visual development found in low-code platforms.

Of course, that’s not the only significant difference. With visual development, you dive straight into specifying the unique value of your application. What does that mean? In traditional application development, hundreds of lines of code are lost to retreading the same old ground. As developers, we go through the same rituals each time we start a new project, and it can be days before we’ve created something valuable.

With a low-code development platform, you can have an MVP in a couple of hours. Sketch or import the data model, drag and drop the workflows, and draw the UI.

This might not seem like development, but consider the end goal of software: it’s to get things done. The visual development inherent in low-code platforms enables productivity almost immediately. There’s no lag while you remember the precise rite demanded by your preferred traditional development language.

That’s not to say visual development can do everything. It’s low-code, not no-code. Hand-coding is reserved for when you need to create something entirely new. And with visual development, your brain power hasn’t been drained away by the minutiae of 100% hand coding.

Modeling Your World: Automated Data Integration

In a low-code platform, describing your data model is simple:

1. Specify data entities (the equivalent of database tables).
2. Define the attributes in those data entities (like the columns of a database table).
3. Draw the relationships between the attributes (specify foreign key relationships).

When you come to access that data in your application, you call it by name just as you would an object in an OOP language. The real difference is that you can largely forget the mechanics of how the data is stored and retrieved. It’s similar to how an ORM works. However, rather than hand coding object definitions and model validation rules, you use the drag-and-drop interface to draw the data model.

Integrating with external data sources should be equally as straightforward. If you were developing in C#, you might expect a LINQ connector for an external data store or a library in NuGet to access a third-party API.

In the most fully featured low-code platforms, it works the same way. Connectors let you access other databases directly or integrate with an enterprise system such as SAP or Salesforce. If the API you want to use has a REST or SOAP interface, the low-code platform will probe the API’s capabilities and make its data available in your application.

Full Lifecycle Management Isn’t DevOps, It’s PostOps

The DevOps revolution has done a lot to democratize code deployment:

1. Commit to git, push to repo.
2. CI triggers, builds, runs tests.
3. If tests pass, CI pushes to production.

DevOps and continuous integration have done a lot to tear down the walls that DBAs and sysadmins love to build. Nonetheless, those three steps represent a romanticized view of DevOps deployment. Sure, it works that way for a minor change. But bring in a database migration or major new chunks of functionality, and the ops side can still require just as much effort as the development.

So, DevOps has been great, but the admin side of running an application still slows down updates and takes considerable manual effort. Low code’s answer is to skip over DevOps and go straight to “PostOps.” Here’s how:

Roles and permissions: A low-code development platform will enforce who can make what changes and who can push to production.

Real-time testing: Most low-code platforms will verify each change you make as you develop to make sure it will work in production.

One-click deployment: You can push even the most complex changes into production with a single click.

Hands-free scaling: As usage of your application grows, the low-code platform will make use of additional VMS, database shards and so on to scale seamlessly to match demand.

The low-code platform handles anything that you’d need to configure manually. As with everything low-code, it’s all about getting your unique value onto the screens of users more quickly.

Fundamentally, building software with a low-code platform is the same as building software any other way. Unless you’re writing everything from scratch in machine code — and no, assembly language doesn’t count — then you’re already taking shortcuts built on the work of others.

With low-code, rather than hand-coding yet another user management system or writing ten tests before a single line of your app’s code, you get straight to creating something new and valuable.

Let’s compare how we would create an application using a conventional web framework to how we’d do it with a low-code platform.

Whether you’re creating with .NET MVC, Spring Boot, or Ruby on Rails, you (and your team) go through roughly the same steps:

1. Figure out the requirements.
2. Plan the architecture.
3. Select a backend framework, some libraries, data stores, and any third-party APIs.
4. Select a front-end framework and hope it isn’t deprecated before you finish development.
5. Choose your deployment stack, set up CI, create an operations plan.
6. Create wireframes and prototypes.
7. Hand code the UI in your chosen JavaScript framework.
8. Write a bunch of failing tests.
9. Define your models and hook them up to data stores.
10. Define and then code your business logic.
11. Create views that will provide and receive the necessary JSON data to or from the front-end.
12. Implement your workflows and UI in your chosen front-end framework.
13. Integrate third-party APIs using their published interface or, if you’re lucky, a supported library in your chosen language.
14. Repeat until the tests pass.
15. Test for security, performance, quality, and user acceptance.
16. Deploy, patch, monitor, and update until the application’s end of life.

With a low-code platform, it would look more like this:

1. Figure out the requirements.
2. Select any third-party APIs.
3. Draw the app’s workflows, data models, and user interfaces in the visual IDE.
4. Connect your APIs, usually with automatic capability discovery.
5. If necessary, add any hand-code either to the front-end or to customize the automatically-generated SQL queries.
6. Test for user acceptance.
7. Deploy to production, then push updates with a single click.

How can you not resist something that cuts development steps in more than half?

Take home message: Enterprise, web, or mobile apps built with a low-code development platform can be as flexible and perform as well as one developed using traditional methods.

Most of what we have discussed here has centered around a full-featured low-code development platform. However, there are vendors in the “low-code space” that don’t offer this level of functionality.

At the conclusion of Gartner’s research for its 2018 hpaPaaS providers, there were 85 vendors self-identifying as such.

But as the low-code industry matures, vendors are trending in one of three directions:

1. Providing a niche platform, going all in on addressing one or two fundamental business problems (e.g., business process management) to the detriment of everything else, or developing apps for a particular medium such as mobile and/or web and ignoring the others, such as enterprise apps. Half of the vendors Gartner included in its 2018 Magic Quadrant for hpaPaaS were, in fact, listed in the “Niche” quadrant.

2. Providing a no-code alternative that attempts to offer a one-size-fits-all approach to app development similar to blog platforms. Two of the five vendors in Gartner’s “Visionary” Magic Quadrant self-identify as offering a “no-code” platform.  

3. Providing a low-code platform that addresses the full spectrum of needs of the enterprise to include those considered niche. Only four vendors met Gartner’s qualifications of “Leader” in the low-code hpaPaaS space.

There is a market for all three types of “X-Code” platforms, but there are marked differences that anyone considering moving to low-code needs to be educated about. Most notably is what Gartner calls, “Completeness of Vision.”

This is a fancy term for “understanding your customer’s needs.” Weighted highly in Gartner’s report are vendors with a good understanding of the market, knowing how to reach the target market (Marketing Strategy), Offering (Product) Strategy, and Innovation.

What this means is that for those considering an “X-code” platform, it is imperative that you understand your own needs, both now and in the future, and invest in the right platform for the long term.

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 the needs of the enterprise or that they are going to replace human coders continue to fall in the face of data to the contrary.

Find a low-code platform that works for your organization, one built by a company with a consistent history of regular improvements, updates, and a roadmap that includes future-looking functionality, such as AI and the ability to integrate third-party tools. You won’t be disappointed in the investment and neither will your team.