What low-code got right
Before writing low-code’s obituary, be fair about why it won in the first place. Platforms like OutSystems, Mendix, Bubble, Retool, and Airtable were built on a correct observation: most software demand never reaches a developer. IT backlogs run years long, engineers are expensive, and a huge share of business apps are forms, tables, workflows, and dashboards that don’t need artisanal engineering.
Low-code answered with three real benefits. Speed, because you could drag, drop, and ship in days instead of quarters. Accessibility, because analysts and operations people could build instead of filing requests. And abstraction, because there were no servers to patch and no deployment pipelines to babysit.
Any claim that low-code is “ending” has to explain what happens to those three, because the demand behind them is not going anywhere.
The price tag nobody reads until year two
Every low-code platform charges the same hidden price for those benefits.
The first cost is the ceiling. Everything is fast until you need the thing the platform didn’t anticipate: a gnarly integration, a custom algorithm, an unusual UI. Then you’re writing workaround “custom code blocks” inside someone else’s runtime, which is the worst of both worlds.
The second is lock-in. Your app is not code. It’s configuration in a proprietary format, executable only on the vendor’s runtime. There is no eject button; migrating off Bubble or OutSystems is not an export, it’s a rewrite.
Then there’s the pricing curve. Per-seat and per-app licensing is friendly at 5 users and brutal at 500. The more your app matters, the more hostage you are.
And finally the talent wall. Skills in a proprietary platform don’t transfer, so hiring is hard, and no ordinary engineer can open your app in an editor and help.
For a decade this was an acceptable trade, because the alternative was real code, and real code required engineers you didn’t have. That is the assumption AI just deleted.
What actually changed
AI didn’t kill the low-code need. It killed the low-code trade-off.
The entire justification for proprietary visual runtimes was that real code was too slow and too expensive to produce. Now describing an app in plain language can produce real code, the very thing low-code existed to avoid, at low-code speed. So if you can have the speed and the accessibility on top of a normal codebase, why would you accept the ceiling and the lock-in?
That question is why this feels like an ending. Not because the platforms stop working, but because their founding constraint no longer holds.
The same benefits, without the ceiling
This is the bet behind Sapilon: take each thing low-code got right and keep it, but change what’s underneath.
| Low-code / no-code | Sapilon | |
|---|---|---|
| Speed | Days, via drag-and-drop | Days, via AI that writes and changes the code for you |
| Accessibility | Non-engineers build in a visual editor | Non-engineers describe, AI builds, and engineers step in anytime |
| What you produce | Proprietary configuration on a vendor runtime | Real code: plain Git, open libraries |
| Customization | Up to the platform’s ceiling, then workarounds | No ceiling: it’s a normal codebase, so anything is buildable |
| Where it runs | The vendor’s cloud, at the vendor’s price curve | Your AWS account, cloud-native |
| Leaving | Rewrite from scratch | Take the repo and go; there is nothing to leave |
| Safety at scale | Platform guardrails | Governed AI: //!AUTO / //!SAFE / //!DEV zones control what AI may touch |
| Pricing | Per seat, per app, forever | Prepaid wallet, pay-as-you-go. No subscription, no seats |
The last two rows matter more than they look. Low-code’s guardrails came from the ceiling: you couldn’t break things because you couldn’t do much. Once AI writes real code, safety has to be engineered instead. Sapilon’s governance zones mark which parts of the codebase AI may change autonomously, which need human review, and which are off-limits. You keep the “a non-expert can’t blow up production” property without the “an expert can’t do anything advanced” property that came with it.
And because the output is an ordinary codebase, the exit is trivial by construction. The strongest argument for Sapilon is one no low-code vendor can make: you don’t need us to keep your app alive.
So, is it the end?
For the need low-code serves, no. Business users will build more software than ever.
For the architecture, the proprietary visual runtime justified by “real code is too expensive”? The clock is running out. New projects will stop choosing low-code first. The platforms will bolt on AI copilots (they already are) without fixing the lock-in underneath. Then the migrations begin, as year-two teams hit the ceiling and realize an AI-first system can rebuild their app as real software. That kind of modernization used to be a luxury; it now runs roughly 10× faster than a traditional rewrite.
If you’re choosing a platform today, the test is simple. Ask what you’re left holding if you stop paying. With low-code, the honest answer is a login page. With an AI-first system built on real code, it’s your software.