Fast self-service data access and enterprise governance are not opposites; but there’s definitely a tension between them, and it’s a persistent challenge for data leaders. A quite familiar same story: the business wants answers now, access gets opened up to deliver them, and a few quarters later nobody can say what "revenue" means or who is allowed to see what.
At one end of the spectrum, everyone can reach everything, and company secrets are one query away. At the other, every request passes through a chain of checkpoints, and self-service stays a slide in a strategy deck. Most organizations swing between the two. Where a company lands on that spectrum depends less on its size or culture than on its data maturity, and on how aware it is that the problem needs deliberate work.
Conversational data agents raise the stakes. An agent lets anyone ask questions in plain language, which is the self-service promise at its most extreme: no SQL, no analyst in the loop. If definitions are inconsistent or access is loose, an agent scales it, delivering conflicting answers faster and to more people.
This article is therefore about governing data agents, and about the foundation they inherit. We start with why the swing between chaos and control happens and what a gradual, working alternative looks like. Then we cover what an agent needs in order to give trusted answers: shared definitions, table metadata, golden queries and awareness of each user's permissions. Finally we look at the two areas where this gets hardest, sensitive data and multicloud estates. We draw on what we see across client projects at Aliz and in the industry; client examples are anonymized.
This pattern is remarkably consistent, and it rarely involves a healthy, gradual transition. It runs in three stages.
The third stage causes most of the pain. We saw cases where teams ran extra MSSQL servers under their desks to keep reaching data they used to have. That data is uncontrolled, but the people using it are perfectly happy with it. With another client we noticed that a warehouse previously built by another vendor met so much resistance that it became a data graveyard: nobody used it, and people stayed on the legacy system and various workarounds.
The lesson is that governance introduced as a big-bang restriction does not remove risk. It just moves the data somewhere you can no longer see it.
Highly regulated environments have the reverse problem. The checkpoints are already there, and in abundance. But access requests pass through so many approvals that a single one can take two to three days, which makes fast self-service unthinkable.
There is a subtler side effect as well. When a system is packed with checkpoints, everyone assumes someone else will catch the error. In one such environment we found plenty of apparent controls and sometimes no data quality tests at all. A large number of checkpoints creates a feeling of safety; it is not the same as data quality.
The healthier path is rarer, but we have seen it work. Recognizing the limitations of a highly decentralized data environment, Delivery Hero used their migration to Google Cloud as an opportunity to rebuild their governance layer iteratively. Their guiding rule was to add only as much control as was needed at any point, so the system never hurt more than it had to.
What made it work was a short list of deliberate choices:
The cleanup was not painless. Early on the system was full of stale individual grants, and removing them to leave only groups was a real pain point. But because the concept was there from the start, it was a contained one.
To borrow an image from the case study of that migration: before, the pizza arrived cut into slices and delivered by 15 different couriers, and you reassembled it at home after it had gone cold. A governed platform delivers it whole and hot. Governance built incrementally is part of how that happens.
That foundation of clear owners, group-based access and agreed definitions is exactly what a data agent inherits. Without it, the agent has nothing trustworthy to stand on. Here is what it needs on top.
The deployment of conversational data agents accelerates the need for robust governance. Without a governed semantic layer, a natural language interface will simply generate conflicting answers faster. To safely allow business users to query enterprise data in plain language, the agent requires a highly structured contextual layer, typically comprising:
If any one of the three is missing, the quality of the results degrades by orders of magnitude. Building this knowledge base once, centrally, also matters: otherwise every user ends up building their own version of the context, and you are back to as many definitions as there are people.
Security in conversational analytics extends beyond the data model; it requires the agent to understand the user's access profile before generating a query.
You can rely on the platform to enforce permissions: queries run in the user's own context and simply fail if the agent oversteps. But that is an inefficient way to operate. A well-built agent knows the access model as well as the knowledge set, so it composes a valid query on the first attempt. It also knows the wider data domain and can point to where the answer already lives. For example, it can:
The result is an experience where the user is not stonewalled by cryptic query failures, and the organization does not have to choose between helpful and safe.
Role-based access only works as well as the data model underneath it. If you work with sensitive data, governance has to appear inside the data warehouse itself, in the way data layers are built, for the whole thing to be manageable. Many organizations deprioritize this. Mobile operators are a typical example: they concentrate on data modeling and analytics, and the question of sensitive data treatment gets less emphasis.
The consequence is either that analytics becomes much harder than it needs to be, or that the organization runs analytics that is not fully compliant. Some weigh the size of a potential regulatory fine against the engineering effort needed to do it properly, and decide on that basis. A conversational agent makes this trade-off sharper, because it lowers the barrier to asking questions of exactly the data that should have been fenced off.
Finally, governance complexity scales significantly in a multicloud estate. While cloud providers offer robust native cataloging and governance services (Google Cloud Knowledge Catalog, AWS Glue, Azure Purview, Databricks Unity Catalog), they are generally optimized for their own ecosystems.
Problems start the moment a second cloud enters the picture: something works only in one direction, or a data set cannot be read at all. Single-cloud estates are fading, as organizations move to multi-cloud to save money, so the question is no longer whether you will face this.
The providers' own answer has moved up a level over time. Governance used to live inside each individual service, such as BigQuery. It was then pulled up to the level of the whole cloud, and now each platform has a dedicated catalog service that spans its other services:
For organizations operating across multiple clouds, defining policies in disparate environments creates blind spots and management overhead. The standard architectural solution is implementing an abstraction layer—such as Apache Ranger—that sits above the individual cloud platforms. By centralizing metadata and policy management, organizations can ensure that BI tools, data agents, and human users are subject to a single, unified set of access rules, regardless of where the underlying data resides. Agents go through it too, which is where the threads come together: the agent's knowledge of the user's permissions and the organization's access rules come from the same place. We are about to implement this approach for a client with a multicloud estate.
A leading national newspaper publisher wanted its editorial and business teams to get answers from their data in German through Google Cloud's Conversational Analytics, without going through a central reporting team. German was one of the main challenges, because the service officially supports only English. Two more came with the data, which covered the company’s editorial operations, marketing and the subscribers: the knowledge that was needed to interpret the data was spread across existing SQL queries, internal documents and meetings, and some of the data was personal.
We built a solution on the foundations described above with the following principles:
The client's testers evaluated the answers for correctness and quality, while our framework automatically validated the results against their reference queries. We used this framework to test every round of improvements. Over the course of the project, the average score for English answers increased by more than 50%, and our tuning brought German answers up to the same standard, despite the service's English-only support.
Because the contextual layer and the permissions live in one place, the same agents work wherever the teams already are: in BigQuery Studio for analysts, in Data Studio next to the reports, and in Gemini Enterprise for everyday questions. Whichever tool someone asks in, the answer rests on the same definitions and the same access rules. That is what the governed foundation and our framework made possible: the client's teams get trusted answers in their own language, without waiting for a report and without anyone seeing data they shouldn't.
Self-service analytics loses its governance when access is opened first and definitions are sorted out later. It becomes unusable when control is imposed all at once. The approach that holds up is to grow governance in small steps alongside the platform, automate access with human approval where it matters, manage groups rather than individuals, and give conversational agents the three things they need: business and metric definitions, table metadata and golden queries, plus awareness of each user's permissions. Where data spans clouds or includes sensitive fields, that governance layer needs to sit above and inside the platforms, not within any single one.
Done this way, teams get answers in plain language, and the numbers for revenue, margin, customers, forecast, pipeline and churn stay the same no matter who asks.