Twenty Years Ago, What You Needed to Listen to Music
Twenty years ago, if you wanted to listen to music, you needed a CD. You walked to the record store, bought one, took it home, slid it into a CD player, and pressed play. For a single song you loved, you usually had to buy the whole album. CDs sat in cases lining shelves. Visiting a friend, you scanned their CD collection to guess their taste. Music was “something you owned.”
Then MP3s arrived. The first wave was a small shock, but once iPods and iTunes settled in, the scene shifted fast. Magazines and newspapers ran “CDs are over” headlines one after another. CD sales did collapse year after year. Record labels bled. Neighborhood record stores closed one by one.
But looking back ten, twenty years later, people didn’t stop listening to music. The opposite happened. Total music consumption in the streaming era hit an all-time high. Average monthly track plays became multiples of CD-era levels, and global music industry revenue eventually surpassed the 1999 nominal peak. What ended was not music — it was the idea of “owning” music. The container holding value shifted from ownership to access. Value itself grew. And new layers emerged on top of the new container — curation, playlists, A&R (Artists & Repertoire, artist discovery and management).
A Similar Headline Shows Up Somewhere Else
Lately a similar tone shows up occasionally: “No-code builders are over.” It’s not as ubiquitous as “CDs are over” was, but it pops up in tech newsletters and on Twitter/LinkedIn often enough — and the volume rises as natural-language coding agents like Claude Code (Anthropic’s coding agent) and Cursor get stronger.
Before going further, let’s pin down what a no-code builder actually is.
A no-code builder is a tool that lets you build business automations without writing code: you drag rectangular blocks (nodes) onto a canvas and connect them with arrows (edges). The major names in the global market today:
- Zapier — the category standard. 3.4M+ users worldwide, connected to 7,000+ SaaS apps.
- Make — visual scenario canvas, famous for branching/routing readability. 5–10× cheaper execution than Zapier.
- n8n — open-source, self-hostable. $2.5B valuation (Series C, October 2025), 3,000+ enterprise customers including Microsoft and Vodafone.
- Microsoft Power Automate — the enterprise standard embedded in the Microsoft 365 ecosystem. Power Platform MAU: 33M+.
- Dify — the open-source AI app/agent builder standard. 139K GitHub stars, $180M valuation, 280+ enterprise customers including Maersk and Novartis.
What these tools share is one screen. “When a customer email arrives → classify the content → send a Slack notification → log in Notion” — you drag that workflow onto the canvas and wire it up. Marketers, operations leads, HR managers — non-developers — can build their own automations. Over the past decade, a large share of routine office work shifted onto these tools, with smaller companies benefiting the most.
But in an era where the cost of writing code is approaching zero, the promise of “automation without code” looks shaky. Tell an AI in natural language “automate this,” and you get working code. Why drag nodes onto a canvas? That’s where “no-code builders are over” comes from.
This series reads that statement through the lens of the music industry. When CDs ended, music didn’t end — the form factor changed. If something similar is happening to builders, what ends and what grows?
Three parts.
- Part 1 (this post) — How the builder’s canvas form factor is commoditizing, and why the market itself is exploding anyway
- Part 2 — Will code agents eat builders, or will builders become the safety rail for code agents?
- Part 3 — When cloud infrastructure (AWS, Azure) and frontier labs (OpenAI, Anthropic) pincer the builder layer from above and below, where does value collect?
Part 1’s one-line thesis:
The builder’s canvas (the drag-and-drop screen) is becoming common. Yet the builder market is one of the fastest-growing enterprise software categories. The story lives inside that gap.
The Canvas Is Becoming Common — Builders Cloned Over a Weekend
Start with what “becoming common” actually means. When one person can clone a category’s core feature over a weekend, that feature is no longer a barrier to entry.
A representative case came from integration-SDK company Composio. Over a weekend, one developer combined three pieces — Next.js, LangGraph, Composio SDK — to build a drag-and-drop agent builder resembling Gumloop. The developer admitted it wasn’t production-grade, but the signal is clear: “node-edge canvas + integration SDK” is no longer a moat. It’s hard to justify multi-million-dollar ARR (Annual Recurring Revenue) on a feature one person can approximate in a weekend.
Put the canvases side by side and the convergence is hard to miss.
| Builder | Canvas Pattern | Integrations | Differentiator |
|---|---|---|---|
| Zapier | Node-edge, hover panel | 7,000+ | Widest SaaS coverage, 3.4M users |
| Make | Scenario canvas, color routing | 1,500+ | Visual branching readability, price efficiency |
| n8n | Node-edge, code-node allowed | 1,000+ | Self-host, OSS, $2.5B valuation |
| Power Automate | Form + flow combo | M365 native + 1,000+ | M365 ecosystem, enterprise governance |
| Dify | LLM pipeline + RAG | Model/tool abstraction layer | AI agent/app builder, OSS standard |
Lined up, design details vary but the core metaphor is the same. Drag a node. Wire an edge. Fill parameters in a side panel. It’s hard for a user to identify which builder they’re looking at from the canvas alone. The difference now lives behind the canvas — integration catalog breadth, execution-engine reliability, pricing.
Builders themselves move as if they know this. Gumloop adding “Gummie” — an AI assistant that generates nodes from a natural-language description — looks like an admission that the era of users drawing canvases by hand is short. Builders are moving from “a tool where I draw the nodes” to “a tool where AI draws the nodes.” The endpoint is natural-language orchestration where the canvas isn’t visible anymore.
And Yet the Market Is Exploding
Here a curious mismatch shows up. If the canvas is commoditizing, the market should be cooling — but the data points the other way.
Look at n8n alone. After pivoting AI-native, revenue grew 5×. In October 2025, n8n closed an Accel-led Series C of $180M, valuing the company at $2.5B. ARR crossed $40M. The company has 3,000+ enterprise customers, including Microsoft and Vodafone. Mid-market customers grew more than 10× in one year. And one more — roughly 80% of new customers were already using Zapier.
That 80% is the critical number. In a typical market-displacement story, new entrants replace incumbents. The n8n data looks more like expansion. The same company uses both Zapier and n8n. The number of workflows worth automating grew so much that two tools coexist inside one organization.
Whole-market estimates point the same direction.
| Year | Automation/Builder Market Size (Global, Estimated) |
|---|---|
| 2024 | ~$20B |
| 2026 | ~$26B |
| 2030 | ~$50B (forecast) |
| 2035 | $80B+ (forecast) |
What drives this growth? It’s not that AI didn’t kill builders — it’s that AI exploded the total volume of work worth automating. Workflows that previously didn’t pencil out for automation — unstructured text classification, context-dependent routing, exception handling — became candidates. That demand poured into builders.
Back to the music analogy: this picture looks a lot like the 1999–2025 music industry. When MP3s arrived, “CDs are over” was half right (ownership revenue collapsed) and half wrong (music consumption exploded). Builders mirror the same structure. “The canvas as a standalone product is becoming common” is correct. “The builder category is over” is not quite right.
One Thing Worth Pinning — What 80% Says
The fact that 80% of n8n’s new customers were already Zapier users shows the real shape of this market. When one organization uses multiple automation tools, it means no single tool handles every workflow. Some workflows fit Zapier’s SaaS coverage; others fit n8n’s self-host plus code-nodes. This isn’t tool-vs-tool competition. It’s workflow diversity pulling tool diversity along with it. Not a winner-take-all market — a market where the whole pie grows.
The Moat Is Moving — A New-Generation Builder’s Positioning Signal
When the canvas commoditizes, builder companies have to find their edge somewhere else. For the past decade, the strongest edge was the integration catalog. Zapier’s 7,000+ app integrations. Make’s 1,500+ scenario templates. “We connect to more apps” was the core competitive sentence. For a new entrant to beat the majors, you had to build a thicker catalog in the same game.
In 2025, one new-generation builder moved to change the game itself. The name is Gumloop, an AI-agent-first builder that emerged in 2023–2024. Much smaller than the five majors above, but interesting in how it positions itself.
Gumloop’s core move was releasing its own integration layer as a free, open-source project (GPL-3.0) under the name guMCP. In plain terms — while major builders treat integration catalogs as proprietary weapons, Gumloop made its integrations freely usable by anyone. Built on top of MCP (Model Context Protocol, the standard for model/tool connectivity), the integrations work even for users who never touch Gumloop’s canvas.
On the surface, this looks counterproductive. Releasing your integration layer for free should weaken your business model. But Gumloop’s bet, compressed to one line: integrations themselves don’t make money. Accelerate the commoditization of integrations yourself, and claim the “standard builder on MCP” position. Don’t compete with the majors on integration counts. Change the game.
Interestingly, this isn’t a one-company aberration. MCP itself was released by Anthropic in late 2024 as an open standard. Through 2025, OpenAI, Microsoft, and Google adopted MCP in their products, and major builders began lifting their integrations onto MCP. In other words, Gumloop’s bet isn’t lonely. The commoditization of integrations is already in motion. The new-generation builder simply acknowledged it first and built its position on top.
When MCP becomes the standard, every builder can call the same integrations through the same protocol. Zapier’s 7,000+, Make’s 1,500+, n8n’s 1,000+ — all gradually normalize on MCP. Bragging about integration count loses its meaning.
So where does value move? Three places stand out.
- Execution reliability and governance. Even calling the same integrations, who runs them most reliably, recovers from failures cleanly, and gives a clear audit trail of who did what with what permission?
- Domain specialization depth. Fifty deep integrations for one domain (financial back-office, supply chain, marketing ops) start to outweigh 7,000 generic ones.
- Ecosystem lock-in. The degree to which a builder is bidirectionally woven into other systems (CRM, ERP, data warehouse) becomes the new edge.
Gumloop’s guMCP is one case where a new-generation company accelerated this shift with its own feet. “If you can’t win on integrations, take the standard’s seat.” It’s a positioning move — and a signal that integrations are no longer at the center of the builder competition.
Closing — What “The Container Changes” Means
Pulling the three pieces together —
Where Value Is Moving in the Builder Market
---
config:
look: handDrawn
theme: neutral
---
flowchart LR
A["Visible canvas<br/>(thinning)<br/>━━━━━━━━━━<br/>Node-edge UI<br/>Drag and drop<br/>Integration icon catalog"]
B["Invisible layers<br/>(thickening)<br/>━━━━━━━━━━<br/>Context — memory and state<br/>Execution — reliability and recovery<br/>Governance — audit, permissions, policy<br/>Domain depth<br/>Ecosystem lock-in"]
A ==>|"Container of value shifts"| BThe canvas thins. The invisible layers thicken.
A builder’s canvas has commoditized to the level of “one developer in a weekend.” And yet the market is on track to roughly 4× over five years. That gap tells us one thing — value no longer lives in the canvas. AI is growing the total volume of automatable work, and which layer processes that work is being redrawn.
The way music consumption exploded when CDs ended, the builder market grows precisely because the canvas-as-standalone-product is commoditizing. What ends is form, not category. And the newly thickening layers — context, execution, governance — become the value container for the next decade.
One question remains. When natural-language code agents (Claude Code, Cursor) take the place the canvas used to occupy, doesn’t the no-code builder category get swallowed by code agents? Part 2 takes up that question.
Series — The Future of Builders
- (this post) Part 1: Is “No-Code Builders Are Over” Actually True?
- Series index: /en/series/builder-future
References
- n8n Series C announcement (October 2025, $180M raise, $2.5B valuation, Accel-led, $40M ARR, 3,000+ enterprise customers, blog.n8n.io/series-c)
- Composio blog, “I Vibe-Coded Gumloop in a Weekend” (June 2025, composio.dev)
- Gumloop, “guMCP open-source release” (2025, GPL-3.0)
- Market sizing — IFR, McKinsey, Grand View Research automation estimates (2024–2035)
- IFPI Global Music Report (CD vs. streaming revenue comparison)
Related Posts
Will No-Code Get Eaten or Get More Precious? — Two Sides of the Code-Agent Era
Code costs trending to zero won't kill no-code. The cost of verifying, reproducing, and auditing outputs rises at the same time. The two stack as layers rather than competing as alternatives.
The Identity Track — From Proof of Personhood to AI Agent Delegation
Proof of personhood and AI agent identity are two layers of the same track. World ID, Passkey, DID adoption curves + Defakto, t54, Indicio funding + payment network entries — the entire identity track in one piece.
In the Headless Era, Where Does Pincered Value Collect? — Vertical Compression of the Builder Layer
The builder layer compresses vertically as hyperscalers and frontier labs squeeze from above and below. Value shifts to custom ops assembly and the defensibility conditions above it.