Skip to content
Go back

No-Code: 88% of Spreadsheets Contain Errors, and That Matters

Illustration of automated workflows connecting different apps

In 2010 Carmen Reinhart and Kenneth Rogoff published a paper that became one of the most influential of the financial crisis. The claim: above a public-debt threshold of around 90% of GDP, average growth collapses. It was cited in parliamentary debates and in the justifications for austerity policies across half of Europe.

In 2013 a doctoral student at the University of Massachusetts, Thomas Herndon, asked for the original spreadsheet to replicate the analysis as a course exercise. Among the errors he found, alongside debatable weighting choices, was a trivial one: an averaging formula whose selected cell range left out five countries. With the problems corrected, the collapse disappeared.

It wasn’t a programming error. It was a mouse-drag error.

No-code isn’t new

The promise of letting non-programmers program is at least sixty years old, and every generation has believed it was the first.

COBOL, in 1959, was presented as a language close enough to English that managers could read and write programs. In the 1980s so-called fourth-generation languages were going to make traditional programming unnecessary. Then came CASE tools, then rapid application development, then low-code platforms, and now no-code.

In 1978 Edsger Dijkstra wrote a short, unkind note on the idea of programming in natural language. His argument wasn’t snobbery: it was that the difficulty of programming lies not in syntax but in the precision required, and that an ambiguous language doesn’t remove the need for precision, it hides it until it’s too late.

In 1987 Fred Brooks formalised the same idea in the most-cited essay in software engineering. He distinguishes accidental complexity (of tools, syntaxes, infrastructure) from essential complexity, which is the difficulty of specifying exactly what must happen in every possible case. Tools attack the first. The second stays where it is.

No-code is, on this reading, an excellent attack on accidental complexity. Which is a lot, and isn’t everything.

The biggest natural experiment: the spreadsheet

The real precedent for no-code isn’t an automation platform. It’s Excel, which is the most widely used programming language in the world and is almost never called one.

In 2005 Christopher Scaffidi, Mary Shaw and Brad Myers tried to count, starting from US labour census data, how many people program without being programmers. The estimate projected to 2012 was over 55 million people using spreadsheets and databases at work, against fewer than 3 million professional programmers. A ratio of twenty to one.

And here comes the figure that should give pause to anyone about to automate a business process with a visual tool. Raymond Panko collected, over years, the independent audits of real spreadsheets used in production by real companies. The aggregate result: errors found in roughly 88% of the spreadsheets examined, with per-cell error rates on the order of 1-5%.

These aren’t spreadsheets built by amateurs. These are the spreadsheets decisions are made on.

The famous cases are the tip of the iceberg: besides Reinhart and Rogoff, JPMorgan’s internal report on its 2012 losses documents that a risk model relied on a spreadsheet in which values were copied and pasted by hand between cells, and in which a division had been replaced by a sum.

No-code doesn’t eliminate programming. It moves it onto people with no version control, no tests, no peer review and no moment at which anyone is asked to check.

Where it genuinely works

All that said, no-code works, and it’s worth being precise about where.

Task characteristicNo-codeCode
Simple, stable rule (“when X arrives, do Y”)ExcellentOverkill
Few special casesExcellentOverkill
Many exceptions and nested conditionsBecomes unreadableBetter
Need to track who changed whatWeakBetter
High volume with direct financial consequencesRiskyBetter

The practical rule that follows is simple: no-code excels when the essential complexity of the problem is low. When it’s high, no-code doesn’t make it go away. It just makes it harder to see, because a diagram of twenty connected blocks can’t be read the way text can.

Before you automate: four checks

  1. Measure before automating. For one week, log how often you do each repetitive operation and how long it takes. Automating something you do twice a month is a hobby, not a gain.
  2. Automate a process you have already written down. If you can’t describe every case in words, exceptions included, the tool won’t handle them for you.
  3. Design the failure, not just the success. What happens if the field is empty, the service is unreachable, the record arrives twice? That’s where 90% of homemade automations fail silently.
  4. Put a notification on every failure. An automation that breaks without telling anyone is worse than the manual step it replaced, because nobody notices for months.
  5. Write down what it does, where, and who built it. A ten-line document. That’s the difference between a company tool and a debt that detonates when you change jobs.
  6. Don’t put data in that shouldn’t leave the company. Automation platforms pass data through third-party services: check with whoever handles security first.
  7. Learn some programming logic anyway. Conditions, loops, variables. They’re the same concepts under any visual interface, and having them clear is what separates a robust automation from a fragile one: see how to learn to code.

My take: no-code is sold with the wrong promise

I think no-code is one of the most useful things to happen to office work in the last decade, and that it’s sold on the wrong promise. The right promise isn’t “you no longer have to think like a programmer”. It’s “you can think like a programmer without also having to learn the infrastructure”, which is already a lot.

I also think Panko’s 88% deserves more attention than it gets, because it describes exactly what corporate no-code automation will look like in a few years: thousands of flows built by different people, never documented, never reviewed, that nobody dares switch off because nobody knows what happens if they do.

A prediction of mine, with no numbers behind it: the skill that will matter won’t be knowing an automation platform, it will be recognising when a process has too many exceptions to be automated by anyone.

Frequently asked questions

Will no-code replace programmers? It didn’t happen with COBOL, fourth-generation languages or CASE tools. Brooks’s argument explains why: tools reduce accidental complexity, not essential complexity.

Which tools should I learn? Less important than it seems. The concept of trigger, condition and action is common to all of them; learned on one, it transfers. Better one used well than five tried out.

Where do I start? With the most boring, most frequent operation you do, not the most complicated one. The first automation is for understanding the tool, not for solving the big problem.

Is it risky for company data? It can be, because data passes through external services. Check with whoever handles information security first, not after.

Does Excel count as no-code? It’s the original and most widespread no-code, and it’s also the one we have the most error data on. The basics are in essential Excel functions.

Sources

This article was written following the process described in how we write. If you find a figure reported wrongly, write to me: I’ll correct it and note the correction at the bottom of the article.

Founder of UpSkillLab, with a Master's in Digital Marketing from the University of Florence. Every article starts from public sources cited in the text and is drafted with the help of AI tools, under my review and editorial responsibility: no purchased content, nothing published without human checking. Read the editorial method or report an error.


Share this post:

See all articles in AI at Work

Previous Post
AI at Work: People Who Use It Are Judged Lazier (There's a Study)
Next Post
Skills: The STEM Wage Premium Halves Within Ten Years