Excel and beyond
Every couple of months the fine readers over at Hacker News work themselves up into a real hoot over Microsoft Excel. They alternate between love and hate.
When they love it, I read how democratic Excel is, how anyone can use it, how it’s the most popular programming language and IDE on the planet, and it’s where the real work gets done.
When they hate it, I read that it’s not a real language, there’s no versioning, collaboration, it’s crude, it’s terrible, it creates silos, errors, it’s wrong, and it’s hard to move away from.
I agree with a lot of these, but trying to unlock the single reason of Excel’s success is a fool’s errand; there is no single reason - there are 30 reasons. Excel has a dozen alarming anti-patterns, a thousand features, and is used in so many ways it’s effectively the plastic of computers; used in everything, used everywhere, because it’s cheap and easy.
And because it’s used in so many ways, it’s unlikely that any single tool will replace it. But that doesn’t mean something can’t absorb it, or beat it in another way.
There’s a lot to love about Excel. For most businesses, everyone at the company has a copy of it. It’s easy to hire for. It’s a fairly solid playground for data exploration. It’s not inaccurate to call it a programming language, or IDE with a visualization library.  As the graphing component at the end of a solid data pipeline, it’s not half bad.
There’s a lot to dislike about Excel too.
The trouble with listing Excel’s many faults is that they are so diverse and esoteric that each may only affect 5% of users or spreadsheets out there. At the same time they are so numerous, and common that each sheet may be affected by more than one. They’re also so well camouflaged that at best they look like user misuse, at worst they are invisible.
Fundamentally, this is because Excel is used in different ways by different people, so it’s effectively a different tool. A good comparison is C++, which has so many features and variations that most organizations end up using only a subset of those features, limiting portability and readability. They’re technically all writing C++, but in practice they seem like different programming languages. Excel users are using the same product, but in such drastically dissimilar ways that they’re different products.
Each user or organization sees only the problem they’re solving, blinding them to features they don’t need, and highlighting the lack of features they do need. For some, versioning is the most obviously lacking feature. Office 365 and Google Sheets offer snapshots, and visual deltas, but in reality these are poorly thought out and don’t offer much. When Linda from sales wants to see why something isn’t in their quote-machine .xlsx file on O365, they can easily see that Scott touched it. But if Linda wants any degree of cherry-picking of cells across versions, or ability to branch, or merge (you know, like Git might offer), they’re out of luck. This is where several external vendors come into play, offering the features Excel lacks.
If you can’t version an individual sheet, you can’t version a fleet of sheets. This is one of the many problems with templating. Linda from Sales? They use a quote-sheet to price out products when they’re on sales calls. It’s simple enough; just copy the sheet, plug in some numbers, export a region as a new sheet. But this means that they, and every other sales person is a machine in a sheet factory. Full-model .xlsx files - the features that makes spreadsheets so powerful - are now a drawbacks. You have any number of versions floating around out there, and no way to perform migrations across them. You can aggregate them into one if you’re clever enough, and link them together using Excel’s foreign worksheet feature, but you can’t wrangle them back into something manageable.
Errors don’t account for much of the perceived drawbacks of Excel, but they’re out there, and they’re bad. When I write “errors” I mean classic #DIV!, #REF!, or #VALUE! as well as off-by-one ranges, and missing formulas, or straight up copy-and-pasted values rather than formulas (which is alarmingly easy to do, and quite common). They’re all basically the same thing; the sheet didn’t function the way the user thought it should, and maybe they saw it, maybe they didn’t.
Errors are when programming goes wrong, and programming is when math gets complicated, and math gets
complicated quickly because people are pretty bad at it. Most Excel sheets are a bunch of
numbers, and a couple of formulas adding up those numbers. By one researcher’s account, around 45%
of the formulas used in spreadsheets is the
formula. So your average user isn’t doing something particularly hard or complex, and
they’re still getting it wrong. Sometimes it’s because of formula complexity, and the order of
operations. But another part is just missing the right range.
Emery Berger is a professor at University of Massachusetts Amherst is that researcher. He created a tool called CheckCell that looks for errors finding ranges that are basically rectangles, (eg: A1: B10 is 2x10 rectangle) and compares rectangles. If two rectangles line up at one edge, but don’t share the same length or width, odds are the user borked up, and one has the wrong range. This is pretty simple, catches more errors than Excels' default bug detector, and still isn’t added to Excel.
CheckCell and ExcelLint can catch errors - so there are obviously improvements to be made by Microsoft. But the short and the long of it is it’s easy to make mistakes in Excel, especially when the displayed output can mask the underlying miscalculations.
If there are so many errors in spreadsheets, but we’re still using them, is it really a problem? If
a sheet throws a
#NULL! and no one’s around to see it, is it still bad? Obviously yes. If
spreadsheets are doing meaningful work, whether we observe the mistakes or not doesn’t matter,
they’re still mistakes.
One of the most concerning aspects of errors is how easily they can propagate and compound in a way
that they can’t in other types of code. If a C++ library has a bug, you can find it, fix it, and
when other libraries that depend on the buggy code get updated they will no longer have the bug as
well. But the copy-and-paste nature of how most formulas get written in Excel prevent that. Copying
and pasting a row-wise
=SUM(A273:D273) / COUNT(A273:D274)
a thousand times for one table-like structure, and then again when the sheet gets duplicated, and
again when the .xlsx file itself gets duplicated shows a viral growth curve in the magnitude of
severity of the bug. Find it and fix it doesn’t work when there’s no common pointer to where that
formula came from. In this sense, mistakes in spreadsheets spread like gene mutations. Subsequent
generations of a commonly used sheet may be fixed if the mistake is obvious enough, but that only
affects the bloodline going forward.
This duplication is a key feature of Excel in many cases. Being able to say “use this same formula
again” through Ctl-C Ctl-V is brilliant, and useful. So much so, it’s used for cells, columns, rows,
workbooks, end entire spreadsheets. A conventional pattern at many companies is what I call “The
Matrix”. It’s a multi-dimensional matrix-like pattern in which each dimension can be any one of the
following: clients (for each client…), interval (daily, monthly, yearly), process type (
accounting, reporting, finance), repetition (do-overs). For example, a company that monitors
ad-spend on behalf of companies might implement The Matrix pattern
$clients * $campaign * $quarter * $process * $interval * $numb_of_do_overs. This spans
multiple sheets and tables, and spreadsheets themselves. Usually one of the dimensions is the
obvious one to use when dividing among spreadsheets. In this case it would be clients. But because
Excel makes it difficult to do things that would be easy in a relational database, you end up
flattening down many dimensions into one or many tables, with a lot of duplication. The result is a
set of spreadsheets that are powerful, and complex.
The Matrix pattern is so powerful (for better or worse) that it’s nearly impossible to get away from. Moving a single dimension out of the spreadsheet is possible, but hard. Moving all dimensions out of the spreadsheets and into more controlled systems? A nearly impossible sell to management, individual contributors, IT, or all three. If you want to improve any of these processes in the spreadsheets, it’s nearly as difficult, and pretty crude; create a new template, tell everyone to use it.
If you happen to work at a company that uses The Matrix, and you’re clever, you may see room for improvement, for consolidation. You combine the various spreadsheets into one. Congratulations, you have created The Beast.
Every company that is dependent on spreadsheets has The Beast somewhere. It’s the biggest .xlsx file you’ve ever seen, and it’s a nightmare. If it was leaked outside the company, the world would stop. If it breaks people wouldn’t get paid. If it produces silent errors you get audited. If you see it you have seen the face of the devil. And if The Beast Tamer (usually a very capable and pragmatic person with a director title) leaves, everyone who has seen The Beast knows it is loose, and begins to run. If you create, tame, or vanquish the beast, you get a promotion, or absent a promotion, a strong notion that perhaps your organization doesn’t deserve you.
Defeating the Beast is the same way you’d defeat smaller Excel files; find a replacement for that pattern of use, get it through purchasing or acquisition or whoever approves that, and then train people. It’s easier said than done, but it’s not un-do-able.
The products that you would purchase range from run-a-sheet services and robotic procedure automation (RPA), to a SaaS product that fits your domain. On the whole, one of the best things that can be done is flow-automation through run-a-sheet services or RPA. It’s best because you can change the flow, and it’s easy to designate someone in the office as the sheet-wrangler; they just plug them together, and everyone else gets to write the sheets with some degree of autonomy.
But the hard part of doing this is that IT often doesn’t want to do it. I read somewhere that most useful tools were brought in through the back door. Excel and Google Sheets were brought in the front door, but with their corresponding suites, so almost everyone has a copy on their laptop from day one. You don’t need anyone’s approval to start tracking returns or calculating burn-down charts or whatever. But if you want another tool you have to ask IT, and they’re often skeptical of anything new and shiny, because they’ll get calls when it stops working. They’re not congenital jerks, they’re just doing the best they can.
Not only is it difficult to replace or automate Excel, it’s difficult to get anything new, including tools that could make Excel safer and easier. This is mainly why best-practices around Excel auditing are really manual. If I had to sum them up in two points it’d be: 1) don’t mess up, 2) have a second pair of eyes to give it a look. Certified accountants are particularly good at this, either by disposition or training. Finance people are pretty good too - mostly because of the financial costs they can incur if they mess up. Everyone else is less than successful when it comes to keeping spreadsheets free of mistakes.
As an analysis tool, Excel is okay. But inevitably someone will want to do something in Excel that gets closer to actual programming; writing something that performs an action. Because of the reactive model of Excel, it’s easy to model a solution to a problem, but hard to take that solution and push it out of the spreadsheet. There are few ways to say “run this calculation with this data, take the result and push it out to another service.”
Which brings us to VBA. To be blunt, few people use VBA, and even fewer people are using it well. VBA is never tested, always brittle, and usually copy, pasted, and modified from someone else’s spreadsheet.
Even worse than VBA is writing some sort of API to read and write spreadsheets. Usually it works like this; someone approaches a very pragmatic developer inside the company, and convinces them to write a wrapper for an Excel file. They do. It’s a click-button thing that pulls in data, writes it to the templated sheet, runs it, and pushes the result out somewhere. Then the developer leaves the company, and no one knows how it works.
VBA, and API work are the two lowest hanging fruits on the tree of automation. In some sense they are forbidden fruits. They will get you cast out of the Garden of Spreadsheets, and out into the cold dark world of software development. You’re on your way to moving off of spreadsheets entirely, for better or for worse.
As easy as it is to see the problems with spreadsheets, they’re even easier to dismiss. An amazing number of companies treat errors in Excel versioning the same way that the American public treated auto accidents before the regulatory requirement of seatbelts; operator error. If people would stop making version control mistakes in their sheets, and would stop getting into accidents, we wouldn’t need version control or seat belts. Until Excel’s Unsafe At Any Speed comes along, it’s hard to see this changing significantly.
It’s just hard to give spreadsheets up. You need to convince individual contributors, management, and IT that there is a better solution, and it’s worth spending money on.
Newer companies can simply avoid it. All new companies are to some degree tech companies, so they’re at least buying, and often times building software. When they build something on top of a spreadsheet, it usually involves the word prototype, so right off the bat they’re not lying to themselves about the quality of their tooling. It’s built to be replaced, and can be thought of as something that’s supposed to break. If it breaks, it means it’s being used enough to be built properly.
This brings me to lo- and no-code tools. In the same way Excel has a thousand different use cases, each a little sliver of the pie, lo- and no-code tools each are little groups of slivers of the pie, slices even. It’s hard to be more specific than that because the market around lo and no-code tools (there has to be a better name) is fragmented, and weird; two dozen start-ups selling little drag-and-drops. I don’t mean that pejoratively, just that they’re selling a gateway to better tools, and it’s yet to be seen whether that gateway works.
It used to boggle my mind that there’s no way to
git diff on a spreadsheet, write tests for it, or
even see a plain-text line-by-line representation of a spreadsheet. But this is really the state of
the industry when it comes to every piece of software ever written; they just don’t come with the
same guarantees of error controls that code or common development software comes with. Almost all
SaaS products, most video editing products, music editing suites, and GIS tools do not come with the
ability to move from correct-state to correct-state through highly-granular version control or
correctness checking. It seems like a chicken-egg situation; almost no one knows what it would look
like for a SaaS tool that offers sales quota compensation automation software (to pick a random
example) to offer version control, so no one really wants it.
Even with all the errors, all the bugs, anti-patterns, and hidden flaws, people want to use Excel. They want it, they like it, they ask for it, they complain if they don’t have it. This is, I believe, the biggest part of Excel’s dominance. And it’s for two reasons: because everyone thinks they’re good at it, and because it’s an extremely transferable and desirable skill in a company. The first one is pretty straight forward, and it’s the Lake Wobegon effect  - everyone thinks they’re above average. But the second reason is the doing the heavy lifting: putting Excel on your CV is good, putting GigaTechComCorp Business Dynamics Analytix 18 Pro™ is bad. Everyone wants to hire an Excel Wizard, no one wants to hire a certified expert in whatever analytics suite your former employer purchased.
There’s a feedback loop between professionals that want to use their preferred tools, and the way most businesses think about work. Because individual contributors want to use Excel, businesses use Excel, even if there are observably better tools for the job. But the business - i.e. management - needs a way to control the flow of work, usually by controlling the unit of work as well. So you end up with people whose job is, in spite of their department, position, or rung on the ladder, is to consume some form of data, and produce Excel files. These two forces; professional preference, and unit-of-work, create a cycle from which it is hard to break free. Introducing a new tool changes the unit of work. If I am good(?) at Excel, and now we’re writing reports with New-Tool-X, am I still writing XLSX reports? Uh-oh, what is my unit of work? What’s my job? If management can change the way skilled labor works, and then drop the axe, it’ll do it ten times out of ten. So in a way, Excel is a wall, or a barricade, or a picket line. It’s insisted existence has as much to do with how management and labor think about work as it does with its features.
If there are so many problems, is Excel really that bad? Yes. Yes it is. It’s slow by many standards, there are better tools. The fact that so many SaaS companies have been made peeling off a slice of the Excel pile is testament to this.  It’s misuse in the past decades has caused quite a lot of problems, and there’s nothing to indicate that we’ve gotten better at using Excel, or that Excel has become safer to use.
One of the most written about examples of Excel’s difficulty is from about a decade ago. A pair of policy experts write a paper (that was, uh, not peer reviewed!) that used a poorly managed spreadsheet, basically changing the financial course of several major economies. Stephen Colbert had a solid segment on it. The spreadsheet involved is still floating around out there, unknowingly (oops!) or knowingly (yikes!). When Excel spurs global austerity measures it seems like a good time to take stock of the situation.
More recently, Excel has made headlines because of its auto-interpretation features for dates. Genomics researchers found errors in each other’s research because Excel interprets the gene “SEP1” as the date September the 1st. In August 2020 (the date, not the gene!) they agreed on a simple solution; to straight up rename the problematic genes.
Another example of Excels danger comes from Enron, on which Berger based some of his research. Why would you use the greatest case of white-collar fraud to study spreadsheets? Well, they’re public, and they followed best practices in the backoffice, where, by all accounts, everything was being done by the book, because most employees of Enron didn’t know about the financial crimes. Basically, the Enron Corpus is like those cross-sections of cargo ships.
Through analysis of the Enron Corpus, Berger was able to find that:
- 45% of formulas are just SUM.
- 60% of sheets have errors.
- Most errors are just data-entry issues. So even as a data entry tool, it is still bad.
- When manually entered data is wrong, it’s not just a fat-finger (eg: 1.267 instead of 1.268), it’s an order of magnitude off (eg: 1.267 instead of 12.67).
While the infamous SEPT1 story is bad on its own; the auto-format issues with Excel aren’t the worst part. The worst part is that it’s hard to use for number stuff in general. The headline " Scientists rename human genes to stop Microsoft Excel from misreading them as dates" is understandably catchy, but a more honest one would read “Genomics edge case fixable; math program is still a dangerous place to do math, join us while we dance on the edge of the volcano”.
But what’s the solution? What’s the fix? If Excel is so messed up, and so useful, how do we move beyond it? For motivated companies, it often looks like purchasing single-domain SaaS products for the obvious misuses at your company, and maybe purchasing some highly flexible BI tool for the more general cases. If you’ve worked for a company changing database systems, email systems, or cloud providers, you get it. It’s often a big, lift-and-shift operation, or a cut-over-on-Saturday. It’s awful.
Very few of the companies I’ve worked with do this with the intention of getting rid of Excel. Usually it’s something like “tracking referrals needs its own system”, or “we can’t have another reporting error again”. If someone with the right ideas is spearheading it, the closest you can get is “Excel causes accidents”.
The other major solution is to just avoid the problem in the first place. A hilarious number of startups I’ve talked to view it as embarrassing to use a spreadsheet for something too long. Using it to track MAUs for a couple of months is okay, using it to track ALL metrics for a year is something that is generally frowned upon. This is because startups ( and engineer-led startups in particular) are more comfortable prototyping something for a while, and buying a SaaS product when they’re not.
The middle ground is mid-sizes, technically savvy companies building a solid data pipeline, modeling their business with the help of a good data engineering team, and letting the end of the pipeline be whatever tool is fashionable; Tableau, Looker, some sort of BI, or yes, Excel.
In the end, I’m tempted to say that the whole debate around Excel is largely wrong simply because of semantics. When we say Exel, or spreadsheets, there’s no definitive, “right” way to use it. People are doing rigorous, real work in Excel. If you know how do use it, and you’re not misusing it, you’re generally fine. If you’re pressured by the constraints of your business, boss, or industry, it’s harder. But the uses cases are so wide that the talk about what Excel is used for is like talking about what code is used for. Everything. You write code to do everything. To solve problems, do things, automate tasks.
To go back to the code analogy; Excel does resemble code, but it resembles how it was used decades ago. Best practices, or at least safe practices were scarce, tooling was far less advanced than it is now. With the current state that we’re in, it’s like if professional programmers could write code to solve business problems, but not to build tooling to make that programming easier. And, like programming languages that have fallen out of use, business will still depend on Excel, but it might be managed differently. Forty years from now, we might depend on Excel the same way. Depending on GCC and C++ libraries that old isn’t uncommon, and it might not be unheard of to depend on an .xlsx file that contains some business logic for whatever app or thing you’re building.
Or something else might come along. It’ll be easier to collaborate, or version, or it’ll play nice with git, or it’ll emulate the network effects of GitHub. Or it’ll be faster, more flexible, or have better macros. Or it’ll run .xlsx or .ods files in a sandbox with a slick UI to give you more control. Or it’ll have all these things. But it’ll only become the next Excel when people stop using Excel, and that might not happen for a while. There’s no shortage of things to build. There are still a lot of beasts out there to tame.
-  The specific thread I'm referring to is https://news.ycombinator.com/item?id=28595155, but if you search on Algolia's HN tool for "Excel" you've find the common refrains: https://hn.algolia.com/?q=Excel
-  https://www.microsoft.com/en-us/research/blog/lambda-the-ultimatae-excel-worksheet-function Even MS calls it a programming language. Sometimes I think this is a bit far - I wish there was a formal definition for the formula syntax, beyond the hazy descriptions in SpreadsheetML.
-  The specific quote is from Joshua Bloch, and is in full at http://harmful.cat-v.org/software/c++/coders-at-work along with other critiques of C++.
-  Companies like https://www.xltrail.com, and it's offered as a feature on a couple other platforms.
-  https://www.nytimes.com/2014/07/27/magazine/why-do-americans-stink-at-math.html has some good examples: significant number of people think a 1/3lb is less than 1/4lb, 17% of prescription errors are caused by incorrect math by doctors or pharmacists.
-  https://www.youtube.com/watch?v=GyWKxFxyyrQ. Emery Berger is a prof at UMass Amherst. Worth watching the whole thing, but I wrote a rough summary in an HN comment https://news.ycombinator.com/item?id=20492951.
-  CheckCell can be found at https://emeryberger.com/research/checkcell/. Definitely worth a full read, but the point is that is' very simple, and exceedingly good at catching common mistakes.
-  Source code for ExcelLint is at https://github.com/ExceLint/ExceLint. A bit difficult to read, but there are more digestible descriptions if you search around.
-  In some cases, The Beast is really a Minotaur, contained in a labyrinth of emails with inscrutably titled attachments like "Number-Munching_2021_-(for_Dave's_project)_V2.1.xlsx".
-  There are so many companies in this space that it's hard to choose just one. Just look at to get an idea. Shortlist is: Nice.com, Hyland.com, Microsoft Flow, Automation Anywhere.
-  I'm not exactly sure where I've read this, but it was something along the lines of: "Most useful tools brought through the back door without permission; relational databases, spreadsheets, IDEs, etc." Basically, that the people in the best position to choose the right tools are the ones, uh, you know, using the tools.
-  https://en.wikipedia.org/wiki/Unsafe_at_Any_Speed If we extended this metaphor further, we can reduce the number of crashes by introducing safety standards, and reduce errors in sheets by introducing better tooling. But if we transitions to public transportation models like bussing and and train lines, we can reduce it further. What are the busses and train lines of spreadsheets? I don't know, but if Excel is the car in this metaphor, it's not Excel.
-  https://en.wikipedia.org/wiki/Lake_Wobegon#The_Lake_Wobegon_effect.
-  "The Unbundling of Excel" is a good guide to this. It was made a couple of years ago, so I'm not sure how many of these companies are still around, but it does show all the ways Excel was, and still is used. It could also be viewed as a window into the mind of VCs, who often need to see how your domain was/is modeled in a sheet before they quite grasp the problem you're solving. A follow up to the article can be found at https://foundationinc.co/lab/the-saas-opportunity-of-unbundling-excel/.
-  https://www.washingtonpost.com/news/wonk/wp/2013/04/16/is-the-best-evidence-for-austerity-based-on-an-excel-spreadsheet-error/
-  https://www.forbes.com/sites/realspin/2013/04/18/that-reinhart-and-rogoff-committed-a-spreadsheet-error-completely-misses-the-point/?sh=7fb165f137e2
-  The Colbert Report did a segment on it in 2013 (https://www.cc.com/video/dcyvro/the-colbert-report-austerity-s-spreadsheet-error) that's very funny. The original paper wasn't peer reviewed, and it looks like, at best they made a common spreadsheet mistake, or at worst they were cherry picking and got caught.
- https://www.theverge.com/2020/8/6/21355674/human-genes-rename-microsoft-excel-misreading-dates. SEPT1 was renamed to SEPTIN1, and MARCH1 is now known as MARCHF1, and so on.
-  Called the https://en.wikipedia.org/wiki/Enron_Corpus, it's basically an email dump of about 600k emails for about 158 employees, including email attachments, some of which were common accounting, financial, and operations-based spreadsheets. It seems like SheetJS has a git repo of the files at https://github.com/SheetJS/enron_xls. I couldn't find another source.
-  Like Stephen Biesty's Incredible Cross-Sections but for a company run by white collar criminals.
- [N] Patric McCormick wrote about this in https://www.notboring.co/p/excel-never-dies
- [N] Another ok article: https://irishtechnews.ie/seven-reasons-why-excel-is-still-used-by-half-a-billion-people-worldwide although I really disagree with the "[problems] with Excel are usually because of misuse" because there are just too many problems to blame the user.
- [N] Finally, because I'm building protobase.io, (which I'm describing as a 10X, next-generation spreadsheet), I'm not exactly objective. But I'm also not exactly biased either. There's a certain amount of subjectivity to observing these spreadsheet patterns and products, and I tried to document the details as much as possible.