Something genuinely good has happened to business intelligence over the last couple of years, and I don't want to be the person who only complains about it. Analytics stopped being something you requested and became something you did. Power BI, and the self-service wave it rode in on, took reporting out of the IT ticket queue and put it on the desk of anyone with a question and an afternoon. That was real progress, and it solved a real, grinding pain.
But every liberation sends an invoice, and this one arrives on a delay. Having spent the last year on the engineering side of the data platform — building the pipelines that feed all these shiny self-service reports — I've had a front-row view of both the promise and the bill. This is my attempt to hold both honestly: what the self-service era got right, what it quietly broke, and what actually fixes it. Because "put the tools back in IT's hands" is not the answer, and neither is pretending the problem isn't there.
First, credit where it's due
Let me be fair to the revolution before I audit it, because the pain it solved was severe and I don't want to romanticise the old world.
Before self-service, a business question meant a ticket. The ticket joined a queue. The queue was long. Three weeks later an answer arrived — after the decision it was meant to inform had already been made on gut feel. Analysts were supplicants, forever waiting on a central team that was forever underwater. The whole arrangement was slow, demoralising, and it meant data informed far fewer decisions than it should have.
Self-service collapsed that loop. Give a capable analyst Power BI and a connection, and they can answer their own question this afternoon. The person with the question and the person with the tool became the same person. That is a profound improvement and it is not small, and anyone who waves it away because of the mess that followed has forgotten how bad the queue was.
The debt nobody entered in the ledger
But here's what I watch happen, again and again, from where I sit in the plumbing.
When everyone can build a report, everyone builds a report. And within a year or so, the typical organisation travels from "we can't get answers fast enough" to a new and stranger problem: "we have four hundred reports, nobody's sure which to trust, and three of them contradict each other in the Monday meeting." The bottleneck didn't vanish. It moved — from production (making the report) to trust (knowing which report to believe). And the second bottleneck is worse, because at least a slow queue produced answers you could rely on.
The shape of the debt is remarkably consistent everywhere I see it:
- Metric drift. The same word — "active customer," "revenue," "churn" — gets implemented a dozen different ways in a dozen different reports. Each is defensible in isolation. None of them reconcile. So two managers present two numbers for the same thing and both are, in their own terms, right, and the meeting dissolves into a debate about whose spreadsheet is correct instead of what to do.
- Extract sprawl. Self-service tools make it trivial to pull data into a local model, so people do — constantly. The single source of truth quietly becomes a thousand private copies, each frozen at a different moment, each drifting a little further from the others and from reality.
- Invisible logic. Business rules migrate into the calculated columns and measures of individual reports, where nobody can see them, review them, or reuse them. The organisation's actual definitions now live scattered across hundreds of files, each owned by an individual, none of them written down anywhere you could point to.
None of this is Power BI failing. Power BI did exactly what it promised. The failure was a hidden assumption: that democratising the production of reports would also democratise judgement about what a report should say. It didn't. Giving a thousand people the ability to define "revenue" is not the same as those thousand people agreeing on what revenue is — and without that agreement, all self-service does is distribute the disagreement faster and dress it up in nicer charts.
Why "give it back to IT" is the wrong fix
The tempting reaction, especially from the engineering side, is to pull the freedom back — lock down self-service, route everything through a central team again, restore order. I understand the impulse. It is also a mistake, and it mostly doesn't even work.
It doesn't work because you can't put that freedom back in the box; people have tasted answering their own questions and they will build shadow spreadsheets rather than rejoin the queue. And it's the wrong fix because the queue was a real problem that self-service really solved. Re-centralising trades one genuine pain for another. The answer isn't less freedom. It's freedom with a foundation underneath it.
What actually fixes it: agreement at the bottom, freedom at the top
The organisations I watch come through the self-service era in good shape aren't the ones that clamped down. They're the ones that built a governed layer underneath the freedom — so that self-service sits on top of a foundation everyone shares, instead of on sand.
Concretely, that means a few things, and they're more about agreement than about technology:
- A certified, governed set of definitions. A small number of blessed metrics and datasets — "this is the revenue figure, defined here, owned by this person" — that everyone's self-service work can build on top of rather than reinventing. Freedom in how you explore; agreement on what the core numbers mean.
- A shared semantic layer. The place where "active customer" is defined once, correctly, so that a hundred reports inherit the same definition instead of each encoding its own. The logic becomes visible and shared instead of invisible and scattered.
- Certification people can see. A way to tell, at a glance, which reports and datasets are trustworthy and governed versus which are someone's useful-but-personal exploration. Both have their place; the sin is not being able to tell them apart.
Notice what this is really about. Underneath the tooling, it's a communication problem — which is the lens I can't stop seeing data through. The self-service mess is fundamentally a failure of shared meaning: the same words meaning different things to different people, with no agreed dictionary. The fix isn't a better report tool. It's the organisation doing the unglamorous work of agreeing what its words mean, and then wiring that agreement into a layer the tools sit on.
Self-service didn't fail. It just exposed that we never agreed what our numbers meant — and handed everyone a faster way to disagree.
Why I think this matters more than it looks
You could read all this as an internal BI housekeeping problem, and shrug. I think it's bigger, because the pattern is going to repeat, and the stakes are rising.
The self-service wave is a specific instance of a general thing: a new technology democratises production, arrives in organisations that never resolved the underlying question of what their data means, and so it industrialises the existing confusion at higher speed. We ran this experiment with reports. We're going to run it again, and soon, with more powerful tools sitting even closer to decisions. The organisations that will handle the next wave well are precisely the ones that learn this lesson now — that the hard part was never the tool, it was the agreement — and do the boring foundational work while it's still cheap.
So here's where I've landed, from the plumbing, watching the water flow. The self-service revolution was right to happen and I'd not undo it. But a revolution in who can build reports demands a matching investment in what those reports are allowed to mean — and we mostly skipped that second part. The bill for skipping it is the four hundred contradictory reports and the Monday-morning argument. The good news is that the fix was always worth doing on its own terms. Self-service just made it urgent, by giving everyone a very fast way to be confidently wrong.
Build the agreement layer. Then let people fly.