Your business rules live in a spreadsheet nobody dares touch

It holds the prices, the thresholds, the exceptions. It is authoritative, it no longer really has an author, and there is only one of it — apart from the copies going round by email.

What you see

• The file has a name ending in a date, and it is not the most recent one.
• One person knows what the fourth tab does, and they were not there when it was written.
• Every update goes through an outside provider, because the file has become too delicate to change in-house.
• Nobody can say which rate applied last month, or when it changed.
• To adapt the scale for a new partner, someone duplicates the file.

What is actually going on

A spreadsheet that carries rules is no longer a spreadsheet: it is software, written in a language nobody owns up to. It has logic, special cases, dependencies between tabs — everything a program has, except history, tests, and somebody accountable for it.

It got there through a series of good decisions. At the start it was the fastest and most flexible way to maintain a price scale, and it stayed that way for a long time. Then it grew, and the flexibility turned against it: nothing guarantees any more that a change at the top does not break a calculation further down. So people change it carefully, then have it changed for them, then stop changing it.

The tell-tale sign is the day updating a price scale is handed to whoever develops the application. It is not their trade, it eats their time, and the value added is thin — but they are the one who knows how to open the file without breaking it. That day, a commercial decision became a technical task, and the business lost control of something that belonged to it.

What it costs you

First the delay: a decision taken in a meeting waits on a technical task before it exists. Then the risk: nothing tells you a value was not overwritten along the way, and you will find out when a customer complains. Finally the stasis, which is the most expensive of all — offers, discounts and tiers get dropped because working them into the file is frightening. The rule no longer serves the business: the business falls into line with what the file can do.

How we go about it

We do not replace the spreadsheet with a screen. We replace it with two separate things, and that separation is the whole point: the values on one side, the machinery on the other.

The values — scales, thresholds, rates, exceptions — stay as data, importable and versioned: you keep a record of what applied on any given date, and you can go back. The machinery becomes code, tested, and replayed automatically before every release.

The spreadsheet does not necessarily disappear either. It can go back to being what it should always have been: an exchange format, not an engine.

What you end up with

Someone from the business changes a price scale, sees what it changes before applying it, and publishes. No ticket, no provider, no waiting.

And you can answer the question that had no answer: which rate applied on that date, and who decided it.

Where we have already seen this

The questions we get asked

The other situations

• Re-keyingThe same order gets typed in three times
• Edge casesThe moment a case falls outside the rules, the front line improvises
• Platform ceilingYour application has hit the limits of its technology