Is Low-Code Dead? The Builder Is. The Governed Data Layer Isn't.

Is low-code dead? The builder is: Airtable sold at 2.7x ARR and AI writes HTML/D3 directly. Governed data and verification gates matter more.

Clint JohnsonPublished 8 min read

Key takeaways

  • Airtable sold at a $1.285B enterprise value, about 2.7x ARR, so the market stopped paying a premium for a no-code builder layer.
  • Abstractions built so humans can avoid code are being replaced by AI-generated HTML and D3 artifacts that you regenerate instead of maintain.
  • Generated artifacts should read only governed views and pass code gates for no inline data and a strict CSP, with a target of 100% governed reads.

Is low-code dead? The builder layer is. The data layer underneath it isn't.

Airtable, the best-known no-code builder of the last decade, just sold to Bending Spoons for about 2.7x ARR. In my own product, we dropped a whole abstraction because a model can now produce the deliverable directly.

Graphite Atlas used to render diagrams through a Mermaid adapter. Mermaid is a text language that lets a person describe a flowchart instead of drawing it. We dropped the adapter. Every artifact in Atlas is now plain HTML and D3. They're beautiful, and they've wowed clients countless times. Nobody has to muck around in Mermaid code anymore.

That's the pattern. Abstractions built so humans could avoid code get in the way once the model writes the code. Abstractions that constrain what code is allowed to do are worth more than ever.

What happened to Airtable's valuation

  • Peak: valued at more than $11B in the 2021 boom, after raising over $1.4B in venture funding (Quartz).
  • Sale: on August 4, 2026, Bending Spoons announced an all-cash deal at a $1.285B enterprise value. That's about $2.25B in equity once you add Airtable's net cash (Bending Spoons). It closed September 4 (AIbrevo).
  • Multiple: Dealroom puts it at 2.7x ARR on enterprise value, which implies roughly $475M in ARR (Dealroom). On the equity value it's about 4.7x.

The popular shorthand, "a $12B company sold for $2B," mixes equity value and enterprise value. Use the real numbers.

Dealroom notes that Airtable didn't exit below what it raised. It also says the multiple is in line with Monday.com and Asana, at roughly 2.2x sales. Airtable is a real business with real revenue. What collapsed is the price the market will pay for a builder layer.

Airtable saw it coming. It relaunched as an "AI-native app" in June 2025 and shipped Superagent in January 2026 (Wikipedia). Bending Spoons says it will double down on Airtable's core strength: bringing teams and workflows together in one flexible workspace. That's a reasonable bet on a workspace. It isn't the 2021 bet that everyone becomes an app builder.

Did low-code ever work in the enterprise?

Yes at the edge, as shadow IT. No past the system of record.

The edge is where low-code earned its keep: trackers and intake tools that teams built without filing a ticket. It stopped at the boundary where the hard parts live, which is permissions, audit, integration and compliance.

In healthcare that boundary is written into law. A vendor that touches PHI needs a business associate agreement first. Systems holding ePHI need audit controls that record and examine activity (45 CFR Part 164). Getting data out of Epic takes FHIR APIs and a real integration, not a form designer. A drag-and-drop canvas has no good answer for any of that. So the serious workflow ends up back in the EHR, the warehouse or custom code.

I can't tell you from the outside how Airtable's enterprise sales went. My read is simpler. The low-code app was where work started. The system of record is where it had to end up.

No-code vs AI: the model doesn't need the canvas

A canvas, a form designer and a drag-and-drop dashboard all do the same job. Each one translates between what you want and what the computer runs, so a person never has to write code.

A model doesn't need that translation. I wrote about this shift years ago as Software 2.0. The builder era was a workaround for a world where only programmers could produce software. That world is gone.

In Atlas the model writes the HTML and D3, and the diagram is the output. We don't maintain it inside a tool. If it's wrong, we regenerate it. If nobody needs it next month, it's gone.

The same logic runs through process mapping. I've argued that AI process mapping should output a graph, not a diagram. Once the typed graph is the record, the picture of it is just a view. The model redraws it on request. Nobody owns a diagram file that drifts out of date.

The builder has become overhead between the model and the deliverable.

People ask me which SaaS tools I'm still glad to pay for. I won't name any. I think they're all up for replacement, because off-the-shelf is being replaced by roll-your-own with Claude. The surface goes first. A vendor that holds your data lasts longer, but only as long as that data and trust are hard to move.

Why data governance matters more with AI-generated apps

Some abstractions were never about saving humans clicks. They constrain. Schemas, types, FHIR profiles, row-level permissions, data contracts and audit logs all belong here. Generated artifacts compile against them. When artifacts are cheap enough to throw away, each one gets less human review. The constraints have to do that review instead.

Addy Osmani called this the 70% problem: AI gets you most of the way, and the last stretch of edge cases, security and maintainability still needs engineering judgment. My answer is to put as much of that judgment as I can into gates the code can't skip.

We built an AI that ships patient portals. It generates complete, API-connected Next.js storefronts from a config file, and it replaced two weeks of integration work per partner. The storefront was the generated part. The APIs and the config it had to satisfy are what made it safe to generate.

In MedScrub we learned that a rule living only in a config file isn't a control. The gate has to sit on the write path (how we did it). Same rule for generated interface code: the agent doesn't get to say done. The validator does.

So value leaves the builder and moves to two places: the governed substrate that artifacts read from, and the verification gate they pass through.

The substrate: one thing to read

A generated artifact gets exactly one thing to read: governed views, through a role that can't see anything else. The artifact never holds a database connection. It calls your API, and the API sets the tenant and runs the query. That API is the same layer agents will need anyway, which is why every service is going to need an MCP layer.

-- The only thing a generated artifact can read.
create view governed.open_referrals as
  select referral_id, specialty, status, created_at   -- no names, no MRNs
  from core.referrals
  where org_id = current_setting('app.org_id')::uuid; -- set by the API, never by the artifact

create role artifact_reader nologin;
grant usage on schema governed to artifact_reader;
grant select on governed.open_referrals to artifact_reader;
-- No grants on core. A dashboard that queries it fails at runtime, not in review.

The model can write whatever HTML it wants. It can only show what the view allows. You don't need a reviewer to catch a dashboard that reads raw tables, because the database already refuses.

The gate: what a generated D3 artifact must pass

The view stops bad reads. It doesn't stop everything. Before a generated artifact gets published, I'd run three checks in code:

  • Every data request names a governed view. Parse the artifact's fetch calls. Anything that isn't your API asking for a governed.* view fails.
  • No inline data. A model that "helpfully" pastes a JSON array of rows into the HTML has copied data past the view, and past its permissions. Fail any artifact that embeds records instead of fetching them.
  • A strict Content Security Policy. Serve artifacts with something like default-src 'none'; script-src 'self'; connect-src https://api.yourdomain. Bundle D3 yourself. A generated chart that tries to load a CDN script or post to a third party gets blocked by the browser, not by a reviewer who happened to notice.

None of these checks care how pretty the chart is. That's the point. The model owns the surface. Code owns the boundary.

I've argued that Postgres should hold the truth in Graphite Atlas, not the graph engine. The D3 on top is disposable. The record underneath isn't.

Is SaaS dead? Test which side each tool is on

SaaS is splitting in two. The system of record is the data, the permissions, the audit trail, the BAA and the integrations. It's priced on data and trust, and it can stay expensive because it's hard to regenerate and costly to get wrong. The generated surface is the views, dashboards, forms and internal apps. It now costs almost nothing to make. Most SaaS products bundle both and charge substrate prices for the surface. That's the part to stop paying for.

Run each tool through five questions:

  1. If you deleted the UI and kept the data and the API, what would you lose? If the answer is "the place we click," it's surface.
  2. Is it the source of truth for something another system depends on? Substrate.
  3. Does it enforce permissions or produce an audit trail you'd show an auditor? Substrate.
  4. Did adopting it take a BAA or a security review? Probably substrate, and the contract is part of what you pay for.
  5. Could a model rebuild what your team uses in an afternoon, against your existing API? Surface.

Cut the surface tools. Invest in the substrate, and expect to pay for it. Even then, no vendor is safe just because its logo is on your architecture diagram. It stays safe only while it holds data and trust you can't easily move.

How to measure moving off low-code builders

Three numbers tell you whether you're actually making the switch:

  • Builder apps retired vs. artifacts generated. If generated artifacts climb and nothing retires, you added a layer.
  • Request-to-dashboard time. The time from "can I see X" to a working HTML artifact. Record your baseline with the builder before you switch, or the number won't mean anything later.
  • Share of generated artifacts that read only governed views. Target 100%. Anything less means a generated surface is touching raw data, and your trust lives in a prompt.

Questions people ask

Is low-code dead?

The builder layer is dying, because a model can write the deliverable directly as HTML and D3. The data layer underneath matters more than before: schemas, permissions, audit logs and verification gates.

Why did Airtable sell for so much less than its 2021 valuation?

Airtable was valued at more than $11B in 2021. It sold to Bending Spoons at a $1.285B enterprise value, about 2.7x ARR, or roughly $2.25B in equity. Dealroom says the multiple is in line with Monday.com and Asana, so what reset was the price of a builder layer, not the business itself.

Did low-code ever work in the enterprise?

Yes, as shadow IT at the edge, where teams built trackers and intake tools without filing tickets. It stopped at the system-of-record boundary, where permissions, audit, integration and compliance like BAAs and PHI rules live.

How do you keep AI-generated dashboards from exposing raw data?

Give generated artifacts a database role that can only read governed views, with the API setting the tenant. Then gate each artifact in code: every request must name a governed view, no inline data, and a strict Content Security Policy.