Back to Insights

    Why Low-Code Projects Stall Before They Finish

    Low-code was named in 2014, and builds still stall in the same place. It is not the tool. Here is the decision that has to happen before you open a builder.

    August 14, 20265 min read
    low-code
    workflow automation
    operations
    smb operations
    process design
    no-code

    What is low-code, and how long has it been around?

    Low-code is a category of build tools that let someone assemble an application from configured components instead of writing most of the code by hand. Forrester analysts Clay Richardson and John Rymer named the category in 2014, and the underlying idea, rapid application development, is older still.

    As of 2026 that makes it twelve years past naming. It is a mature category being introduced as an emerging one.

    Why do low-code projects stall?

    They stall on an undecided exception, almost every time. The build moves quickly while the work is well understood: the screens, the fields, the path where nothing goes wrong. Then it reaches a case that was never settled, and progress stops there.

    What kind of question stops a low-code build?

    The ones that sound small and turn out to be policy. What happens when a customer changes an order after it ships. Who approves the credit. Does the original job stay open, or close and reopen. Whether a partial delivery counts as complete.

    None of these are technical questions. They have never been answered in writing, because until now the answer was whatever the shift lead worked out that day.

    What should you decide before opening a builder?

    Write down the three exceptions that come up most often. For each one, decide two things: what happens, and who has the authority to call it.

    That is one afternoon of work and it costs nothing. Do it and the build really is as fast as the demo suggested. Skip it and you have bought a quicker way to stall.

    Does the choice of tool matter at all?

    It matters less than the sequence. A capable builder with undefined rules produces a half-finished application that runs alongside the old process. A modest builder with clear rules produces something the team actually opens.

    • A build with settled exceptions ships and gets used; a build with open exceptions parks and gets renewed anyway.
    • A tool chosen for its feature list impresses in a demo; a tool chosen for the rules it has to enforce survives contact with a real week.

    What does a finished version look like?

    For a dental hygienist scheduling operation, the pain was manual back and forth that produced recurring double bookings. The build that worked was narrow, and the rules were explicit. Coverage requests go out automatically, an available hygienist confirms in one tap, and everyone gets a daily update.

    Double bookings came down and so did the weekly time spent managing the schedule. The system was not complicated. What made it finishable was that someone decided in advance what happens when two people confirm the same shift.

    How do you know your business is ready to build?

    Ask your ops lead to describe the three most common exceptions in a process, then ask someone else the same question. If two of the answers disagree, the tool is not the next purchase. The decision is.

    Curious how we think about operations work?

    Our alignment framework shows where strategy, work, and systems drift apart — and how to close the gap.

    See the framework

    Related Insights

    Yes, There Is an API. Does It Carry the Numbers You Need?

    The software has an API. The numbers you want may not be in it. What to ask before anyone promises an integration, and what an honest scope looks like.

    Why Can't We Use the Feature the Demo Showed?

    The demo showed it working. Your account does not. The three forms the demo gap takes, and the checks to run before you plan anything on a system.