← back to field notes
research DISPATCH Nº 47 4 MIN READ

The death of the drag-and-drop builder

For fifteen years, workflow automation looked like a canvas of rectangles connected by lines. After watching three million runs across twelve thousand teams, we're convinced the canvas was always the problem.

There is a particular kind of fatigue that sets in around the twentieth node of a Zapier zap. You know the one. The connecting lines start to cross. The error-handling branch you added last week now has its own error-handling branch. Someone on the team named a step "Step 7 (FINAL) (USE THIS ONE)." You open it on a Monday morning, stare at the canvas for forty seconds, and quietly close the tab.

We've spent the past eighteen months instrumenting that moment. What we found surprised us: the canvas isn't failing because the workflows got more complex. The workflows got more complex because the canvas required them to be.

The short answer

The canvas is not failing because workflows got more complicated. Across the 12,000 teams studied over eighteen months, median Zapier zaps grew 31 percent in node count year over year while the work they accomplished grew 9 percent, and the difference was scaffolding: wrapper nodes, formatter steps, lookups and glue.

That is the bargain every drag-and-drop builder asks you to make. In exchange for a visual picture of your logic you agree to express the logic in nodes, one node per action, a diamond and three lines for a branch. Of 8,400 workflows audited, 43 percent of nodes existed only to translate data between two other nodes. They did no real work. They were grammar.

Describing a workflow rather than drawing it turns out not to be a different input method for the same model. The interesting work moves into the compiler, which is where the knowledge lives that a lookup sometimes times out and that a duplicate-key error should be treated as success, and once the compiler is doing the real work the editor stops needing to look like a canvas and can look like writing.

The canvas tax

Every drag-and-drop builder shares an unspoken bargain: in exchange for a visual representation of your logic, you agree to express that logic in nodes. One node, one action. Two actions, two nodes and a line. A branch becomes a diamond and three lines. A retry becomes a node that points back at itself in a way that looks vaguely alarming.

The canvas didn't help us think clearly about workflows. It forced us to think about nodes.

The cost shows up in our data. Across the 12,000 teams we studied, median Zapier zaps grew 31% in node count year over year, but the work they accomplished grew by only 9%. The rest was scaffolding: wrapper nodes, formatter steps, lookup nodes, glue. The canvas was eating itself.

◆ DATA Of 8,400 workflows audited, 43% of nodes existed only to translate data between two other nodes. They did no real work; they were grammar. The canvas charged a tax in rectangles.

The natural-language alternative

What happens if you stop drawing the workflow and start describing it? We thought we knew. We assumed natural language would be a thin layer over the same model, a different input method for the same canvas. It is not.

Here is a workflow our customer Anika at Resend wrote on a Tuesday afternoon, in plain prose, in our editor:

# trigger
When a new customer signs up on our website

# steps
1. Look up their company info using Clearbit
2. Score the lead with AI: company size, industry, role
3. If score > 80, create a Salesforce deal + assign rep
4. Send a welcome email via Gmail with their name
5. Log to Google Sheets and post to Slack #signups

What the compiler produced from this prose was an 8-node playbook with one branch, five API integrations, and, critically, an error shield Anika never asked for, because the AI knew Clearbit sometimes times out and Salesforce sometimes rate-limits.

In a drag-and-drop tool, Anika would have spent the next two hours adding retry logic, formatter steps, and conditional fallbacks. In ours, she spent six minutes describing what the workflow should do, and the compiler handled what it should be.

The compiler is the product

The interesting work, it turns out, isn't the editor. It's the compiler. Translating "if the score is high" into a branching condition is the easy part; what's hard is knowing that the score might be missing, that the field might be a string instead of a number, that the Salesforce API will occasionally return a duplicate-key error and you should treat that as success.

That kind of knowledge isn't visible in the editor. It lives in the compiler. And once you accept that the compiler is doing the real work, the editor stops needing to look like a canvas. It can look like writing.


Three predictions

We think the next three years of workflow automation will be shaped by three forces:

None of this means the canvas disappears overnight. There are workflows where a diagram is genuinely the right representation: complex state machines, multi-week orchestrations, anything with significant parallel branches. But those are a minority. For the long tail of "when X happens, do Y and Z," prose is better. It always was. We just didn't have the compiler.

◆ READING If this argument interests you, three pieces to follow it up with: our post-mortem on the retry-loop incident, the interview with Kira Hartman on consolidating 400 zaps, and Mei's essay on naming things the AI will read later.

We'll keep writing as the data accumulates. If you're building workflows, in any tool, and you want to share what you're seeing, the inbox is open: field-notes@dugong.live.

research essay
share · copy link · ✦