Skip to content

Strategy

Low-code limits: where the ceiling is, and the signs you are near it

Four constraints set a low-code platform's ceiling, and the signs you are near it are visible.

Computing America. Applications, integrations, data analysis and AI/ML engineering.

Describe the app
3 min readComputing America
A rugged tablet at a factory workstation under a low steel beam with hazard striping.

In short

  • Low-code platforms build real production applications. Where they stop depends on how much of the stack the platform lets you reach.
  • Four things bound you: the vendor's roadmap, the runtime it ships, the test and release tooling it offers, and a blast radius shared with everything else on it. Some platforms add Java or code extensions or deployment pipelines, so check which yours has before assuming the limit.
  • Signs of the ceiling are practical: an auditor asking who changed what, a system with no connector, outsiders needing access, or a team that won't touch the app before a busy period.
  • A new service makes the moved capability auditable only if it is the sole writer of that capability's data. Decide where the data lives before building it.
  • At the ceiling, move the one capability that crossed it out of the platform before you consider a rebuild, and settle who can run the old app without its builder.

Four constraints set the ceiling of a low-code platform: the vendor's roadmap, the runtime it ships, the test and release tooling it offers, and a blast radius shared with everything else on it. Some platforms offer an extension point past them. Ignition's scripting runs in Jython (opens in a new tab); going past it means writing Java modules with the Ignition SDK (opens in a new tab), which is conventional software development. Mendix lets you add custom Java actions (opens in a new tab), and Power Apps lets developers build code components (opens in a new tab). Which extension points, version control, pipelines and audit features yours has is the first thing to check.

This is for the person who built an app with screens and a database that people use on a tablet on the floor, and for whoever sponsors it now. Low-code platforms run production operational apps, and building one was a reasonable call.

What the ceiling is made of

ConstraintWhat it means in practice
One vendor sets the paceAdopting anything new (a protocol, an identity standard, a language feature, a security control) is bounded by the vendor's roadmap, which their whole customer base sets, not you.
The scripting stack is whatever shippedYou write in the language the platform ships, on the version it ships. Dependency management, current libraries and hiring for the skill are outside your control unless the platform accepts extensions in a general-purpose language.
Test and release discipline is bounded by the toolingAutomated tests, code review, staged environments and a deployment pipeline exist to the extent the platform supports them. Where it doesn't, the mitigation is care. Check what yours offers: some platforms support Git and deployment pipelines.
Blast radius is sharedAn app inside an operational platform shares its exposure. A compromise or a bad release isn't bounded to the app, unlike a separate system with its own credentials and failure domain.
More skill or budget inside the platform doesn't move these four constraints; only an extension point the platform offers does.

Signs you are near the ceiling

Organizational signs:

  • People outside the team that built it depend on it, including people who don't know it's a low-code app.
  • The team won't modify it before a busy period.
  • An auditor, a customer or a regulator has asked a question that requires knowing who changed what, and when.

Technical signs:

  • It needs to talk to something the platform has no connector for, and the workaround is a scheduled export.
  • Somebody has asked whether people outside the organization can reach it. That's an identity and exposure question the platform may not answer well.

If the real problem is that your existing systems aren't kept patched, backed up and answered when they break, that is managed IT, not a software project. Ask a provider, including a different division of this firm (opens in a new tab).

Move one capability, not the whole app

The instinct is a rebuild. Start instead with the one capability that crossed the line: the part that must be identity-aware, auditable, reachable by outsiders, or connected to something the platform can't reach. A replacement justified only by "the original was built the wrong way" gives operators nothing they did not already have. Move that capability's data with it and remove the app's direct write path. Otherwise the audit trail covers only the writes that happen to go through the new service.

Fig. 1
  1. Operators

    Same screens as today

    • To Low-code app
  2. Low-code app

    Everything that works stays

    • To New service beside it · calls, never writes
    • To The capability's data · removed: the app no longer writes here
  3. Outsiders and auditors

    What the platform can't serve

    • To New service beside it
  4. New service beside it

    Identity-aware, auditable or reachable

    • To The capability's data · every write
  5. The capability's data

    Written only by the service; the app has no write path

The app calls the service and loses its write path; the service is the capability's only writer.

SourceThe pattern described in this article; no measured data.

Before you change anything

Write down three things: which one capability crossed the line, who depends on the app, and who besides its builder could run it tomorrow. Then use them in order. The capability is the scope of the new service. The dependents are the people you tell before the interface changes. If the builder is the only person who could run the app tomorrow, name and brief a second one before anything else.

Next step

Tell us about the app that outgrew itself.

What it does, how many people depend on it, and what broke last. We will say whether it is at the ceiling or a guardrail short of it, and what carrying it forward would involve.

Reply
A person replies, not a sequence: within one business day, from someone who would be on the engagement.

Packages

Start with a package

Four packages, each with its price on the page. Pick one and buy it online.

Billing