From paper trays to purpose-built: a short history of business data going where it needs to go

Every business runs on the same basic problem: information created in one place needs to end up somewhere else, in a form someone can use. That's rarely a copy-paste job. It usually needs transforming (a phone call becomes a job card) and enriching (an order number gets a customer history attached). And once data is moving across a business, someone needs to see what's actually happening: which orders are stuck, which numbers don't match. That visibility, observability, is what lets a business run efficiently instead of finding out about problems from an angry customer.

How companies have solved that problem has changed completely over four decades. Each new solution fixes the last one's pain point, then creates a new one. Here's the run through, and why I think we're finally close to breaking the cycle.

1980s: paper and word of mouth

Everything lived on paper, moved by note, phone call, or someone walking across the office. Cheap and simple, and reliable in a narrow sense: paper doesn't crash. But finding a record meant finding the folder, and verbal handoffs drift the more people they pass through. Observability barely existed. Knowing how the business was doing meant walking the floor and asking, or asking someone to collect all the data and prepare a report.

1990s: everything in a spreadsheet

Excel and email meant a filing cabinet's worth of data could reach a supplier or client in seconds. Cost dropped, and data entry got faster. But spreadsheets are single-player software pretending to be multiplayer. Email a workbook to three people and you get three versions back, with no audit trail and no warning when a wrong formula quietly corrupts a report. And every cell still had to be typed in by hand, so in that sense it was only a small step up from paper: faster to move, but just as manual to update.

2000s: software of your own, data still moving by hand

Dedicated apps arrived: accounting software, a CRM, an inventory system, each good at one job. Accuracy within each system improved, and real access control became possible. But the systems didn't talk to each other, so data moved by CSV export and manual import, recreating the email problem inside better software. Each silo had good visibility into its own patch and none into the whole business.

2010s: the cloud arrives, spreadsheets become the glue

Xero, Salesforce, and a wave of SaaS tools moved software into the browser. No installs, better infrastructure, subscription pricing that suited smaller businesses, at least at first. Pricing quickly turned into per-user fees with no real technical basis for it, since one more login barely costs the vendor anything. It just made the bill scale with headcount rather than with actual use. And a business ends up running three, four, five, six of these tools, each one used at maybe 10 to 20 percent of what it can do, none of them doing exactly what's needed, so the business bends its own workflow around whichever tool is closest to fitting rather than the other way round. On top of that, five or six disconnected cloud tools meant the spreadsheet came back as the connective tissue, with someone becoming the unofficial keeper of the file that stitched everything together.

2020s: integrations bolt it all together

Most businesses sit here now: cloud apps wired together with Zapier, Make, native integrations, or custom integrations someone built in-house. When it works, manual entry drops close to zero and the systems finally feel joined up. And that's fine, as far as it goes, but you're still left with a Frankenstein's monster stitched together from different platforms, each with its own logic, its own login, and its own way of breaking. The deeper issue is that every app in the stack is generic, made to serve everyone at once, so there's no way to reshape it around how your business actually works, and no way to fix it yourself when it doesn't. That shows up as both an integration problem and an observability problem. One API change on a vendor's side and an automation silently stops firing for weeks. It's really a control problem as much as an observability one. That dashboard belongs to a vendor who built it to fit thousands of other businesses at once, not yours specifically, so it was never going to show you exactly what you need to know, only what fits the average customer. Nothing tells you whether this order, right now, is actually moving. You find out when the customer calls.

2025: purpose-built, integrated only where it earns its place

The businesses getting this right are moving away from stacking generic tools, back toward software built for how they actually work, with integrations kept to the one or two connections that genuinely need to exist.

Until recently, this option was really only open to companies with deep pockets. Building purpose-made software from scratch took a full development team and a budget most small businesses simply didn't have, so purpose-built stayed a big-company thing while everyone else made do with off-the-shelf tools. AI changed that cost equation fast. Development that used to take a team months now takes a fraction of the time, which brings purpose-built software within reach of an ordinary SMB, not just the big players. Weigh that against several mass-market subscriptions whose monthly bill keeps climbing per user, plus the time saved from a system that actually fits, and the payback period is often short.

I'll be direct about this, since it's the argument I keep making to clients: six SaaS subscriptions glued together with Zapier isn't cheaper than a purpose-built system once you count integration maintenance, per-seat licence fees, and lost orders when something silently breaks. A system built around your workflow is faster to use, more reliable because there are fewer points of failure, and cheaper over a couple of years, even though it costs more upfront than off-the-shelf SaaS.

Observability is the part people undersell. A purpose-built system can show what's actually happening, stuck orders, short stock, numbers that don't reconcile, in one place instead of a dozen vendor dashboards. That's the difference between catching a problem the day it happens and catching it a month later in a reconciliation.

2026 and beyond: AI does the last mile

Purpose-built systems are starting to use AI for the genuinely messy work: reading a supplier invoice that arrives as a photo, flagging an order that doesn't match the usual pattern, drafting the first pass of a report. This closes a gap that's existed since 1980. Even a great purpose-built system still needed someone to handle the badly formatted email or the handwritten note. AI is actually good at that mess.

It's changing observability too. Rather than someone deciding what to monitor, AI can watch normal patterns and flag what doesn't fit, an order value miles outside range, a delivery running late against its own history. That's closer to having someone experienced quietly watching the business than to reading a chart.

Forty years on, the underlying problem hasn't changed. What's changed is how close we've finally got to solving it properly, instead of working around it one more layer at a time.