Automate Power BI to Databricks Migration with UC Metric Views

Summary

Kasal is an open-source agentic framework that accelerates the migration of Power BI semantic models — including complex DAX measures and dimensions — to Databricks Unity Catalog Metric Views by 75–80%, replacing months of manual migration effort with automated, human-in-the-loop generation.
The workflow extracts semantic model metadata via Power BI APIs, uses LLM automation with guardrails and regex pattern matching to generate UC Metric Views, and surfaces results in Genie for AI-driven discovery, making previously locked Power BI business logic available to models, agents, and applications.
Coca-Cola HBC partnered with the Kasal team to migrate over 2,000 Power BI reports, with the project beginning approximately two years before the presentation and accelerating significantly after LLM and vibe coding capabilities became available.

Automate Power BI to Databricks Migration with UC Metric Views

Power BI semantic models contain critical business logic locked away from modern AI applications. Migrating these to Databricks Unity Catalog requires translating complex DAX measures and dimensions, a process that typically takes months with manual effort and fragile results.
In this Databricks keynote, learn how Coca-Cola HBC used Kasal, an open-source agentic framework, to accelerate Power BI migration to UC Metric Views by 75-80%. Watch the end-to-end workflow: extract semantic model metadata via Power BI APIs, generate UC Metric Views with human-in-loop quality validation, and surface results in Genie for AI-driven discovery. Discover how guardrails, regex pattern matching, and LLM-smart automation combine to scale across 2,000+ reports without sacrificing accuracy or governance.
🤝

Chapters

FAQs

What problem does Kasal solve for Power BI to Databricks migrations?

Business logic in Power BI semantic models is encoded in DAX measures and dimensions that are proprietary and difficult to translate to Databricks Unity Catalog Metric Views manually. Kasal is an open-source agentic framework that automates this translation, reducing migration effort by 75–80% compared to a purely manual approach.

How does the Kasal migration workflow ensure quality and accuracy?

Kasal combines guardrails, regex pattern matching, and LLM-based automation with human-in-the-loop validation to check that generated UC Metric Views are accurate before they are promoted. This approach balances automation speed with the quality assurance required when migrating business-critical metrics at scale.

How did Coca-Cola HBC use Kasal to migrate their Power BI reports?

Coca-Cola HBC partnered with the Kasal team to migrate their DAX-based Power BI KPIs to Unity Catalog Metric Views so that business logic would be available across Databricks Genie, AI models, agents, and applications. The project started approximately two years before the presentation and scaled to cover more than 2,000 reports.

How are migrated metrics surfaced to business users after migration to Databricks?

Once DAX measures are translated to UC Metric Views in Databricks Unity Catalog, they are surfaced through Genie for AI-driven discovery and natural language querying. This makes previously locked Power BI business logic available throughout the Databricks Data and AI platform to models, agents, apps, and embedded systems.

Full transcript

[00:11] Today's keynote is uh started with the ingredients. Uh Craig from OpenAI was talking about the quality of the models or are about the ingredients that comes in. Today we'll talk a bit about the kitchen and uh and how we can use those ingredients.
[00:26] But if you look at it, you have a lot of important data in different restaurants, call them BI and a lot of those data, you want to use them everywhere. You want to use them in models, you want to use them in agents calling them, you want to use them in apps, you want to
[00:42] embed them in systems. So today I'll be talking to you together with Max from Coca-Cola and David from data bricks. We'll mainly be talking to you about our journey how we helped
[00:59] Coca-Cola to migrate the uh PowerBI dashboard KPIs into UC metrics and use them everywhere within the UC metrics. Hi everyone, I'm Ne Tom together with Max and David. We are from Switzerland.
[01:17] In the p in the past year and a half, we started actually working on the project two years ago, but in the past year and a half, we've been heavily focusing on how we can migrate all these DAX statements into into our data layer. And
[01:33] this project started before the VIP coding. Thankfully the the vibe coding and code came in so a lot of acceleration happened there but mainly today the three parts would be I would be focusing mainly on the foundation
[01:49] whenever we're leveraging the migration there are a lot of LLM calls agents configurations we need to make sure that guardrails are there we wanted to make sure we have human in the loop and a lot of those are going to be covered by that
[02:06] first part and then Max will talk a bit about the journey. How was it when we started with that particular business problem? What did the journey look like? What was the pain point? And David who was working closely with the account, he
[02:22] will walk into the internals of what we've built actually to make this happen. So before we start, I wanted to cover the kitchen that helped us to build all these different building blocks. So the kitchen mainly is leveraging the
[02:38] ingredients and those ingredients are a lot of things to think of. So when I'm building an agentic framework, there are tooling that I need to use. How can I make sure I do the evaluation there? There are
[02:55] memories, model selection. We have to make sure that context is segmented properly. We had to make sure that we have the human in the loop that might be triggered or it might be it might be uh scheduled. There might be things around
[03:11] how do we need to make sure that the observability is running and that is all was used as the foundation within Castle to allow basically in that system we could easily be able to create all these agents
[03:26] as a non-technical person and all the heavy lifting around a lot of the evaluation model quality is happening there and within Castle a business user will be able to create these agents Give them a goal, a backstory, mandate a
[03:43] task, what they need to do, what are the tools that they need to do and then the users would be able to test those runs immediately. They will be able to look at the feedback from those different tools and if something is not good, they can hand them over to an AI engineer
[03:59] that is then going to work on the quality of the tool calling on the guard rails. How are we going to tackle the guard rails? Is it a probabilistic guardrail or is it a deterministic guardrail? And it happened to be that you can actually use a lot of
[04:15] deterministic if you are knowing what the output is going to be you could call deterministic functions to easily use them. So today I'll walk you in the first bit on that how are we able to build those different meals and once we build that we deploy that natively into
[04:32] data bricks. So I'll jump into the demo and what you see in front of you is the normal yet another chat assistant interface where this could be the place where that one particular business user
[04:48] is using. So within this let's say I identify the most effective marketing campaign. I want to identify the channels per country then send reviews to the partner team to the marketing team. I could run that using a common
[05:04] memory across all my different users within something called a casal workspace or I could say no I want to keep it in this particular session and I'll spin up that I'll send that prompt that prompt is going to generate the plan that will run in the background. So
[05:20] if I switch here, this is the user interf the business user interface. I'm switching to a a AI engineer interface which you could see that one single particular prompt that got basically built a plan a visualization of all
[05:36] those agents and tasks that are happening and as an AI engineer you would be able to see that one particular run in in the history directly. You would be able to look into the particular tasks. You could see what are the MCPS where used. You could look at
[05:52] the guardrail that you want to send. You could look at the um uh traces that are in ML flow. A lot of that capability that a business user should not be seeing or would not understand what is happening. That's where the AI engineer would be able to look into. So going
[06:09] back into that casal interface, a business user will still be able to see the timeline of the different tasks. But this is here a case where that could be a query going to Genie that generates a dashboard or a report. But what Castle allows you to do, it allows you to
[06:26] generate any content. But the key element here is how can I actually generate a consistent UI regardless. So as a as within my company I have the the brand I have the identity I have the color I have the format of my particular
[06:42] artifacts. How am I able to produce that single output? So here you could see it created a presentation. Here it could create a dashboard. Here you could be some genie discovery on different tables. Here you could see it creates a particular Anki or you could create a
[06:59] particular mind map or you could create an interactive ski uh quiz that persists in lakebase. So everything you see in front of you is persisted in lake base. You could create albums you could go through. So you have a multimodel in
[07:14] terms of what you're able to get back. You could even create videos that generate gives you back that consistent UI that you want to be able to have. So here I'll switch into the flow builder part of it and that's where a lot of the effort what we've been doing in the
[07:29] migration and the human in the loop. So suppose now the simple approach I said identify the most effective marketing campaign extract some information. This is multiple agents with multiple tasks but I want to group them together into a
[07:45] team of agents and then I want to be bring all the team of agents and build them in a flow. So here in that example I would be able to say identify the marketing campaign or let me load that from the catalog.
[08:02] Identify the marketing campaign then trigger the effective ones then be able to identify the uh campaigns by particular countries and then trigger an email to the chief marketing officer or send an email for a reviewer report and
[08:18] once all is done roll out the reports that what we want to do. So that foundation this is what David will be able to walk us through and be able to show us how we could do that. So this example that I just showed here when I was in the agent builder that I was able
[08:35] to create this plan I'm able to save it in a catalog and that catalog becomes powerful because as a business user I would be in the chat and rather than saying my particular prompt to create a dashboard
[08:51] I could actually because I know I could trust that catalog because the AI engineer lever made sure that all the evaluators, the judgments, the guardrails, the tools are all aligned. I know I could trust that by simply loading that one particular
[09:08] whatever plan from my catalog and then I would be able to run it. I'd be able to inspect it. I'll see what is the output of that particular agent. What is it doing for me? And then I'll be able to export that. And after that we know that those particular runs are tracked in uh
[09:26] mainly uh ML flow and they connect to the different uh datab bricks components. Everything around think of it as this is a simple app. You go on the marketplace today was one of the first apps on the datab bricks
[09:41] marketplace. You go on the marketplace, you search for CAS, you install it and you have that app running and and connecting to all the primitives and data bricks. So let's understand the architecture. How does it look like? So here you have this concept of
[09:57] workspaces where you are adding different users to the workspaces. They have a catalog of those business plans that they want to do. So we'll show you the plans of the migration afterwards. But every workspace they have the unique tools for those users with the pro with the
[10:14] instructions for those set of users with the MCPs the tools the memory indexes that are available all with a seamless authentication with data bricks because it is running on apps and most importantly everything is persisted on
[10:30] lakebase and integrated within ML flow. So now you have an app that allows you to have business skills. A lot of not skills in terms of binary and how you need to do that in terms of I have a business problem and I want to be able
[10:46] to gather those particular insight in order to derive that particular report. This is abstracting the level uh on top of the technology and everything is going through the unity catalog AI gateway and then you have the integration with the various primitives
[11:03] that are provided by data bricks that allows you to leverage if you want to leverage Genie if you want to leverage agent bricks if you want to make sure that you have all the managed MCPS and the configured MCPS from data bricks. Now you ask what does this has have to
[11:19] do with the migration topic? Did we land in the wrong room? Uh that happens to enable and accelerate a lot of the effort and uh Max and David will be able to elaborate more on that but Max now will
[11:35] talk a bit about how the journey looked like at Coca-Cola and what were the different pain points. Thank you so much Neym. Um so before I dive into that part um I just wanted to also say thank you again to Neym for actually being with us on
[11:52] this journey from the very beginning because fun fact it was last year when he had showed it to us and uh we just saw a lot of potential just with a very very basic version of Cassal and so we actually started to explore and try out Casal with regards to various little use
[12:09] cases just see what's what is it capable of um Because Newman was always explaining how it is built on the shoulders of the data bricks giants, right? Because it can access it was built to access Genie spaces. It was built to access ML. So it work with all of those things and we were basically
[12:26] part of this whole journey of how David and then later on when David joined as well on that project. Um how they improved it over time. And the nice thing was that we could always give feedback and that through that feedback they were able to build a solution that
[12:42] is really valuable to an enterprise. Um and with that being said so what was something that we faced? Um we had tried out various things with Cassal and we saw some success stories. We had little
[12:58] proof of concepts. And then there was one project that we had started independently of that. It is what we called IDORE and it stands for insights discovery on report. And you can imagine it a little bit like a kind of like a genie project with the
[13:14] difference being that we were trying not to use genie not because we don't believe in genie quite the opposite but because we had built everything around other vendors suppliers other tools for example what do I mean by that genie is
[13:30] amazing if people trust in it if people know how it works we at Coca-Cola we are a salesdriven an organization with many business users who have hardly anything to do with tech. They don't know what AI can do, where the limitations are. Um
[13:48] they are scared of using it. Um so unsure as well about the quality of the output. So we had to find a way of okay, how can we bring AI in such a way that they will trust it. Now what do people know? they know in our
[14:04] case PowerBI because all our reports are built on PowerBI and the main request was hey can we like kind of make it more interactive than just using with that now one could say amazing we use co-pilot for example because co-pilot is available we thought about that well
[14:21] there are licenses license cost a lot of license cost uh there's no API to it so whatever we want to build on top of that for example one request was as well hey we okay I could generate some insights for those test users who did have the co-pilot license but um I actually also
[14:37] want to share it with other people. I will always have to copy paste and we were like you know what with all the vibe coding we can easily create our own application we can just connect to via APIs we can make that possible we can have full control through our own application how we want the user
[14:53] experience to be add new features do an endto-end experience not possible we cannot connect to that co-pilot for that report via API simply not available and then also we had the problems of back Then when we tried it
[15:10] there was still no tracing yet properly of how the agent reasoned. Nowadays there is but also back then it couldn't uh cross filter uh among the rep different report pages only what was visible. I mean there were a lot of improvements that have been done but still there were limitations that even
[15:25] nowadays we wouldn't be able to provide the product that we want to this eer basically. So we said okay we could try to use Genie but we still went against it because we have so many PowerBI reports and what is the problem the
[15:42] semantics and the measure definition all the KPIs they don't live in data bricks because we had never defined them there over the last decades we had built PowerBI reports which means all the tables that we ingest which do indeed come from Unity catalog amazing it's the
[15:57] same source that Genie could also use Right. But we are missing the business logic. The whole business logic is not there. We don't have the filters. We don't have the measures on which granularity they are being aggregated. All of the rules. Um certain things that
[16:13] are maybe not loaded into PowerBI, right? Because maybe it is the same data source, but they only uh only load certain subsets of that. Um and we said, okay, um if we have to translate all of that, it'll be quite an effort. let's try to
[16:30] make our own co-pilot. So we went out and said okay we have this idea of our application we can deploy it in data bricks of the chat interface we can send emails uh we use model serving to generate a nice email the PDFs we store everything in lakebase with all the logs
[16:47] amazing we have an amazing app idea and we went to uh vandav and said hey can we work with you on having something with casal that and that's something what we did actually so we said in casal we had agents that actually what did they do they connected to the PowerBI semantic
[17:03] model. So getting all the information about which tables are being loaded, what are the filters being applied, how are they joined, what are the measures that we have there, how are they being renamed in the front end because what does a PowerBI developer do? Loads the columns and then I have my visual. Oh,
[17:20] let me rename that column. And it's just visually there, right? So we can get all of that information as well. get some examp ex exemplary data and then try to have our own casalogentic crew of translating text to ducks.
[17:36] It worked. It worked for a simple report amazingly. So now we had another report we wanted to try as proof of concept which was our supply chain report or one of our most heavily used and important supply chain reports
[17:51] was not feasible. the accuracy was not it was simply not as good. Why? Because the more complex the whole model got the semantic model the less accurate the translation was to DAX. And even nowadays I so we're every now and then re-evaluating trying okay how good did
[18:08] co-pilot become we're still having problems in consistency and robustness. Uh the compute doesn't scale. we're limited to the fa fabric's capacity, right? Because even though we generate the DAX, we're sending it over to fabrics for the compute to happen to run
[18:24] that DAX query. Um, and we still don't have the monitoring. Those are things that we would have to implement ourselves to how could we do that. We were able to improve it a little bit by again referencing Genie, how does Genie improve? We have example queries, example expressions. We tried to mimic
[18:40] that as well through vector research um of exemplary DAX queries and it improved but again it was very difficult to get something robust. So we said there is no way around actually using something that we know is a good product, a good technology, something that works which
[18:56] is Genie. But what do we need for that? We need UC metric views. We don't have access. Genie cannot access the semantics of uh the PowerBI. But again we don't have the UC metric views. So we set out and said again,
[19:11] hey, we know we already can access the semantic model to try to do the translation. Can we not access the semantic model with Cassal cruise and then instead try to build new cruise to instead of translating the text to DAX
[19:28] getting it and translating this whole thing into the necessary Ummetric views basically reflecting what we have in PowerBI intotric views. So that's what we did with David specifically and it was very nice because we had that in the very beginning the general draft and
[19:43] then we could iterate with him back and forth and the nice thing is even though we didn't uh implement most of it ourselves we had our own things that we had tried out he had a lot of things that he tried out we merged we had a great collaboration on that and he even continued to extend it further because
[19:59] once we had the UC metric use we still had to create the genie space ourselves but he is already on it to We even have that automated a full end to-end experience. Um and the nice thing is once we had that we had accuracy we had scalable compute because we had serverless compute that we could attach
[20:15] to Genie. We had the full monitoring and those were all the stuff that allowed us to overcome it. But again the blocking part was the semantics right that we needed to enable and that's what we did. Um so just for you to imagine how is it
[20:31] how does it look like. So this is just a a mock report because I can't show actual reports. Um but the idea was again we have the report and next to it for the business users right so that it's trustworthy so that they can see and have the idea of okay we have an app
[20:46] on the right side. So you see on the top is the total supply chain one that we had implemented but then we have this financial report. This is this one. And then the idea is that basically they will see their report that they know that they trust. if they want to try out first, they'll ask questions next to it
[21:02] that either they will find the numbers here or they can continue to deep dive because that's a nice thing about Genie, right? Genie can deep dive into things that that you don't see in a PowerBI report because the reports are meant to be visual. You implement based what on
[21:18] what you want to see topline, etc. So everything that needs to be on a different view, a different granularity, that's that's why business users want to be able to communicate with the data. But in this case, they're able to see it right next to it to have this whole experience there. And literally what we're doing actually is just we're
[21:34] having this experience just wrapping it into something that they know, they trust. Okay, it's our logo. Okay, it's a it's our Helen plus that's our AI what we call it our product. It's all the same AI. So people know it, people trust it, people believe in it because they
[21:50] see the numbers next to it. Um and we have the full control, right? We deploy it on data bricks apps. We develop it. Whenever we have a new idea for a feature, we can just integrate it. So that's also another nice thing, right? We can use all of the datab bricks
[22:05] technologies because they are accessible through API. They are open source. And also Cassal, for example, we even though we didn't contribute the additional stuff because we were sharing all of the code with David. So he was still implementing, but Cassell is a git project and that's a nice thing. It's
[22:21] not locked to anything. So anything that you would want to be to build on top of that add a new feature you can do it do the PR request and David and Nemo will have a review and just integrate it as easily as that and you have people who can track and trace it in Casal. So that was also allowing us to set guard rails
[22:38] to have a look at the agents. Genie one is amazing. We saw all of that today in the keynote speech but everything has like a different kind of purpose and this casal agentic framework gives us full control. We can set the guard rails of the agents. We can add new agents. We
[22:56] can add new tools, new skill sets because we can add new code and simply do the PR request. So in this case, oh I think I forgot to mention, but basically so once this continues, you saw I don't know if you watched the video or not, we were able to share the email and so on
[23:12] and so forth. I kind of skipped that now. I hope it's not too bad, but you get the gist of it. And while this worked for one of our most complex reports, the supply chain report, this was now one PC. It was a successful one. We presented it actually at our supply chain leadership conference and they're very excited about it and wanted for
[23:27] other reports as well. But again, we have a lot of other reports, 2,000 plus reports still on PowerBI where we need this migration. And what we had done so far is that we had done it for this one report. But again, there are measures that can be shared across other reports.
[23:44] So far, they're locked in every one of those proprietary semantic models in PowerBI. So you'll have to define them always a new and in UC metrics you could just reuse them for whatever DD space you want for whatever other dashboard you want and that's really a nice thing
[24:00] and again we had just done part of it with David so he'll explain to you more how the journey can look like how the future can look like of really scaling this whole migration because we will continue the journey with him. We actually got the approval just last week which is amazing. Um yeah and this is
[24:17] basically what we have done so far and you'll see now how it can continue. Cool. Yeah. Thanks Max. So I think this should work perfect. Um yeah before before we dive a bit into how we made
[24:33] this happen actually I first want to focus a bit more on the why we did it even although I actually think that nobody really questions the why these days. So imagine like Max presented right? You have all your different bunch of users. You have your classical Excel users. You have your classical BI users.
[24:50] Now there comes this whole realm of agents and they all want to use the same KPI. It boils literally down to here's my net sales revenue in all those systems the same number. Hopefully it is in reality governance of all of that is literally a bit of a problem these days
[25:07] because many of those things are recreated. And this is actually where the idea of using symmetric fuse from data bricks comes in. It's the foundation. You define your KPIs once and can consume them from any kind of system you want. Whether it's your Excel user where you serve it via the Excel
[25:22] integrator from data bricks, whether it's your datab genie, whether it's your AI agents, your data scientists, your analysts, they all use literally the same measure definition underneath the hood of those Ummetric views which themselves just build up upon the classical golden architecture, Medallion
[25:40] architecture which is around since quite some time which on top sits off your data. Ultimately this is it. And now the big question is how do we get there? Because right I I think it's not the question of is this important. I think this is quite relevant for any company.
[25:57] The problem is really more the scale. For instance, at Coca-Cola they have around 2 to 3,000 PowerBI reports. It is a team of 20 people. They develop those reports in roughly 6 to 10 years. So you have quite a bunch of legacy lying
[26:13] around there. And usually if you come to a CTO CIO and say hey let's move that to use symmetric use they say cool idea but they don't have 6 to 10 years this is usually quite the problem um how can we
[26:28] make this faster and this is literally where Kasal now comes in with the idea what we had and where everything hopefully ties together now because what we did and what I will demo in a minute is literally a little flow that we presented and which you can integrate If
[26:44] you install it from the marketplace where you actually fetch from PowerBI from your API endpoint in PowerBI which you have the only requirement which you need is you need to have minimum a premium workspace and you need to have a service principle usually two things which most enterprise customers have
[27:01] extract some stuff which we will have a look in the demo and ultimately deploy a symmetric view and the part on this slide which I will not demo today but which Max also briefly mentioned we even went actually one step beyond And based upon those UC metric cues, we
[27:17] stuff them into a large language model which are deployed on your data bricks environment. We actually create I don't know how much you know about Cheni but basically in Cheni you have instructions and you can give example queries and what we basically do is based upon those Ummetric views we generate descriptions
[27:34] of the workspace which again can be reviewed by humans in the loop and we generate example queries on top of your UC metric views. This would be then that genie space line which you then can deploy and those genie space instructions you ultimately can download them as YAML file. So everything open
[27:50] format that you can also put it into your GitHub repositories or into your Azure DevOps repos. same line literally for the PowerBI to AIBI dashboards um migration story there. We just parse from PowerBI to tunnel endpoint to extract the visual containers and
[28:07] recreate this as bar chart, line charts, you name it, whatever you might need um as JSON files which are then deployed in your data bricks environment. This is the last part which I won't demo today. I will focus for the journey of the UCtric use because this is also where
[28:22] you can build and scale on top of it. But just that you know where we are located at important as briefly mentioned everything literally open format in kasal it's an open project per se um but we are using no proprietary language everything is yaml everything
[28:39] is JSON those are the two file formats which we use and everything and this is the most important part for me why I personally believe that many BI migrations are failing to some extent or not that easy is because everybody these days believes agents can do this out of
[28:56] nowhere. But we believe in Cassal deeply in the context of human developers who curated that knowledge over the last 6 to 10 years that they add a value and I always call it with my customers the LLM smart approach use large language models
[29:12] for the boring tedious task extracting stuff from APIs creating a basic draft of a metric and then leveraging humans in the loop. the experts who built all that kind of stuff to review it and create it and approve the next step. They are basically the gatekeepers for
[29:28] every step of the process. This is the idea behind what we implemented and also of what I will show now. So with the new marketplace installation
[29:44] everything what you will get is out of the box a preconfigured workspace which we call BI specialist workspace. So this entire flow which you saw if we go now into the agent builder studio and go to catalog you will find all the
[30:01] preconfigured crews which data bricks already created. So those are custom crews which are specialized on PowerBI migration effort and there for instance is one like this the pipeline generation tool and the only thing where all those efforts are different is literally in
[30:19] the workspace where your specific model is hosted the data set ID and as mentioned we also need a service principle with specific access rights because otherwise you're not able to use the Microsoft's provided API endpoints and those are basically the configuration ation parameters which are
[30:35] dependent on whatever the crew does for the configuration extraction from PowerBI you need a couple of PowerBI endpoints and parameters and metadata around it. Once you come to the end of the where you want to deploy to use symmetric views, you obviously have to create for instance um tokens or
[30:53] specific connections to data bricks which are the m metadata which you need there. But this is literally how all those crews and I can also have for instance a look at the deploy one. So this is how all those crews are literally preconfigured dependent on what they want to do. Here for instance
[31:09] if you have a u metric at some point you want to deploy it. So the agent needs to know to which workspace do I have to deploy it and with which warehouse and should I put it into a certain schema. Those are the things which are relevant here and this is how everything is adopted every single step and ne before
[31:27] presented right that out of those crews you now let's say configure those four crews which you need for the um migration so that you have your symmetric deployer and you can combine it literally like that. So
[31:43] first in this crew and this is something the only effort which you then have to do apart from the metadata is that basically you need to configure this flow where you say hey first of all I want to extract based on this specific data set I want to extract my data from
[31:59] the powerbi rest API endpoint which then goes into a configuration to create symmetric views which is governed by humans in the loop for the review and then it goes into a quality validator because we also also saw that especially
[32:14] the configurations coming out of here. So literally what is in PowerBI large language models tend to do mistakes in the translation which is per se not the problem but very annoying to find let's say in a measure where you have 23 to 40 different filter items good luck
[32:31] searching the one which is missing and this is why we implemented as a first best approach a simple regex pattern search where we basically check are the filters which you see in your JSON that you extracted the same as the ones which you see in your transpile u symmetric. So to have a bit of a quality guardrail
[32:48] and this is then presented and people can download it and this is what we already will see and then you deploy it. So how does this look like? So let's say I would have started um I can also start it and just will take some time because this entire flow takes around 10 to 15
[33:03] minutes without human review. But basically if you started it the output which you get from this crew is for me personally the most important one because it's actually the Jason of the PowerBI which is underneath it and we created for BI developers are usually
[33:20] not the hardcore coders. So this is why we developed this little UI which is familiar to if you're a BI specialist they are most of the time familiar with their semantic models and this is just what we extracted and the idea now is this is exactly where we believe
[33:36] strongly that the humans add value that here now the BI developer comes in creates and edits this JSON file this is by LLM smart which is then persisted into lakebase once they approve it and it then would go into the generational step of the UC metric view which you had
[33:54] here where the output then is literally a UI experience like that. So let's go to my first most favorite table for instance fact PE00002 there you just see on top always the original not transformed not large
[34:11] language model transformed implementation of what is in your PowerBI. So the joints which were extracted from the JSON file. So literally the dimensions which are used in your PowerBI report and all the original measures which you had in this one specific table. And at the bottom of
[34:29] the page you then have literally what we actually want and this is the transpile umetric view. The first part which is the source and you in um PowerBI you call this the mquery transformations. Then you have you can have comments which are auto detected the joins which
[34:45] is the relationships of your table. So most of the time master data dimensions which might be joined the dimensions so on which level you want to aggregate it and measures are the literally the measures which the duck statements basically from your PowerBI report either the base measures but also then
[35:03] the more complex one like the switch statements which were decomposed and everything from your original PowerBI. Same developers BI specialists can re review one table after another. Those would be exactly the tables you find in your PowerBI report. approve them and it
[35:19] would go to your quality step which is then the real one which you have and this is basically if you don't see any kind of red thing you don't see any red sign surprise surprise in the demo uh that you can download all of them and this is basically you see how this goes
[35:36] in in the background and this just exported us the 27 or 26 YAML files which we just transpiled and which you then can deploy in your infrastructure. So this is as simple as it gets and from top of that you can then create cheny
[35:51] spaces or use them in your existing BI stacks and enable everything. So just some reference numbers because Max briefly explained hey um what are
[36:06] what are some examples what you can expect. We basically did this now I think with two or three reports. So the supply chain one was the most complex one including user acceptance testing which I know takes some time. The original PowerBI journey took roughly 14 weeks.
[36:22] So let's say 3 months plus minus. Um we with casal with the team we had a very good team and they had a um know a lot about the PowerBI. The real translation of the PowerBI report took two weeks. So one sprint with user acceptance testing.
[36:38] We move the entire report in one month which is roughly a 75 to 80% reduction in work effort and all of a sudden this 6 to 10 year timeline boils down to one and a half year which for 2,000 reports
[36:54] is quite the fair number I would say and this is basically what we want to demonstrate here and what Max also briefly mentioned with those three wins which we had we are now basically allowed to tackle the 80 most complex reports which they have companywide
[37:09] because this is basically the step-by-step approach. I hope that with that we convinced you um that possibly you metric views and casal can help you to create a functional Swiss clock that you can run
[37:26] your agents, your models and unify your business users any agent on any cloud and on any BI tool wherever you want it. Thanks for joining our talk and also for the time spending with us.

Learn more about the Databricks Data and AI platform.

The information provided herein is for general informational purposes only and may not reflect the most current product capabilities or configurations.