Low-code is a way of building software where most of an application is assembled and configured visually, instead of written line by line. Code is added only where it’s actually needed.

On a low-code platform, the parts every application needs (screens, forms, data storage, sign-in, permissions, notifications) already exist. The people building the application describe what they need: the data it holds, the forms people fill in, the steps a request goes through, and who can see what. The platform turns that into a working application.

Low-code and no-code

The two terms are often used interchangeably, but they describe different things.

No-code tools are designed for people who don’t write code at all. Everything is visual. That makes them quick to learn, and good for simple applications. But there’s a ceiling. When a requirement goes beyond what the tool offers, there’s no way past it.

Low-code platforms use the same visual approach, but they’re designed for teams that include developers. When a requirement goes beyond the visual tools, a developer adds code (a query, a script, a custom component) exactly where it’s needed, and the rest of the application stays visual.

In practice, the most useful platforms combine both. People who understand the process build most of the application visually, and developers handle the parts that need code. The result is one team, working on one application, instead of a business team writing requirements and a development team interpreting them.

How an application gets built

The details vary by platform. On Plant an App, an application typically comes together like this:

  1. Model the data. Define the things the application manages, such as applications, cases, inspections, and people, and how they relate. The platform generates the database, the lists, and the detail pages from that model.
  2. Build the forms. Create the forms people use to submit and update information, with validation and conditions built in.
  3. Define the process. Model the workflow a record goes through: the steps, rules, decisions, and notifications.
  4. Connect other systems. Read from and write to the systems the application depends on (ERP, CRM, legacy databases) and publish APIs for others.
  5. Set who can do what. Connect sign-in to your identity provider and decide, by role, who sees and does what.
  6. Add code where it’s needed. A query, a script, or a custom component for the requirement the visual tools don’t cover.
  7. Keep changing it. Requirements change, and the same team changes the data model, the forms, and the process as often as needed.

What low-code is good for

Low-code shortens the distance between the people who understand a problem and a working system that solves it. That makes it a strong fit for the systems off-the-shelf software doesn’t cover well: case management, permitting and licensing, inspections, portals, internal operations, and the processes that fall between an organization’s core systems.

It’s also why low-code is often used to modernize legacy systems: the new system can be built step by step, alongside the old one, and keep changing after it’s live.

Where platforms differ

Most low-code platforms make the first application look easy. The differences show up when the system becomes important:

  • The ceiling. What happens when a requirement goes beyond what the platform does? Look for a way to extend it with code and your own components, not a dead end.
  • Integration. An important system has to work with the systems around it, through APIs, databases, and identity providers.
  • Governance. Every change needs to be recorded and reversible, with versions kept in your own Git repository.
  • Where it runs. Some systems have to run in your own cloud or your own data center, not only in the vendor’s.
  • Security evidence. Independent certifications, such as SOC 2 Type II and ISO 27001, rather than claims.
  • Licensing. Pricing per end user makes a system more expensive the more it’s used.

We cover these in more detail in Evaluating a low-code platform for a system that matters.

Low-code for important systems

The real promise of low-code isn’t building applications faster. It’s that a remarkably small team can own a remarkably important system: build it, connect it, run it, and keep changing it for years, without a new software project for every change.

That’s what we built Plant an App for.