12 November 2026
CI/CD in Power BI test
How to develop, monitor and deploy solutions with greater confidence in Microsoft Fabric
When a report is created by one person and used by a small team, building it in Power BI Desktop and publishing it may be enough. However, as reports become more important and more people start working on them, questions begin to arise: what has changed? Who made the change? Was it tested? And what happens if something goes wrong in production?
This is where CI/CD comes in. Continuous Integration (CI) helps bring together and validate changes throughout the development process, rather than leaving everything until the end. Continuous Delivery (CD) helps move those changes to subsequent environments in an organised and repeatable way. In Power BI, this has become particularly interesting because Microsoft Fabric can connect its workspaces directly to a Git repository.
The PBIX file remains useful for day-to-day work in Power BI Desktop. However, when we want to understand exactly what has changed between two versions, comparing PBIX files is not the easiest approach. With Power BI Project (PBIP), the project is saved in a folder and file structure that can be tracked using Git.
This is where TMDL and PBIR come in. TMDL stores the definition of the semantic model in a code-based format, including tables, measures, relationships and other settings required by the model. PBIR organises the report definition, such as pages and visual elements, into separate, structured files. This makes it easier to identify and discuss changes when someone modifies a measure or a visual with the team.
Visual Studio Code can help you inspect these files, review what has changed and submit updates to Git. It complements Power BI Desktop by helping connect the files to the configured repository; it is not a replacement for the tool we normally use to create reports.
This is the main difference compared with a traditional development process: a Fabric workspace can be connected to a branch in an Azure DevOps or GitHub repository. This means that the repository is no longer separate from the environment where the team works with published content. We simply need to ensure that the workspace is assigned to a Fabric capacity.
This synchronisation can work in both directions or in just one, depending on the repository settings. If someone changes a supported item directly in the workspace, that change can be synchronised to Git. If a change is made to the project and pushed to Git, the workspace can be updated to receive that version. It is important to note that this synchronisation applies to the definitions of supported items, not to copies of the data used by the reports (only their metadata).
As each workspace can be connected to one branch at a time, the team needs to agree where changes should be made and when synchronisation should take place. If the workspace and
the repository contain different changes, conflicts may need to be resolved before work can continue.
Throughout this process, we stop using the Publish button in Power BI Desktop and instead work with Visual Studio Code and the Git repository.
A simple view of the architecture
Working in Power BI Desktop
One option is to work as usual in Power BI Desktop. The developer opens the PBIP project, makes the required changes and saves the files. Then, using VS Code or another Git tool, they record the changes and push them to the repository. Before merging them into the main version, the team can review them through a Pull Request. If testing in Fabric (online) is required, a separate workspace connected to the branch containing those changes can be used.
Working in Fabric
In certain scenarios, development can start directly in Fabric. A developer uses a separate workspace connected to their branch and pushes changes to supported items to Git. This allows them to experiment without interfering with the shared workspace. The choice between Desktop and Fabric depends on what is being developed and the team’s working methodology.
Once a change has been developed and validated, a decision needs to be made about how it reaches users. There is no single solution that works for every team. The following table summarises three possible approaches, ranging from one that relies more heavily on Fabric’s built-in features to one offering greater automation.
Deployment Pipelines help move content from one environment to another and, where supported, adjust settings specific to each environment. The fabric-cicd library, on the other hand, makes it possible to automate deployments using project files. The choice depends on the level of control and automation the team requires.
The BI team needs to add a Gross Margin indicator to the sales report. The developer creates a branch for this task, opens the PBIP project in Power BI Desktop, updates the report, creates the metric and saves the project. In VS Code, they review the changes, create a commit and push it to the repository.
The team member or person responsible reviews the changes through a Pull Request and runs the agreed checks. If they want to confirm the results in Fabric (online) before merging, they can update a feature testing workspace from that branch (known as a feature workspace). Once approved, the changes are merged into the main branch, and the Development workspace receives the updated version after synchronisation between the workspace and the repository.
Finally, the team promotes the content to the Test workspaces and, once the necessary tests and approvals have been completed, to Production. Instead of publishing directly to the Production environment, which is difficult to track, there is now a clear path from the initial change to the version that reaches users.
One of the most useful decisions is to establish where the official version of the solution will be stored and agree on how changes will be incorporated into it. Working in dedicated branches, reviewing changes before merging them and using separate workspaces when necessary, all help prevent conflicts. It is also worth checking at the outset which items and features are supported by Git integration and Deployment Pipelines, as not everything works in the same way.
Another important consideration is to configure data source connections and environment-specific settings before deployment.
Automation can save time and effort, but it does not replace testing or essential approvals.
Permissions in Git, workspaces and automation tools should also only be granted to those who genuinely need them.
Another important point is to have some familiarity with creating and managing branches, particularly to ensure they are always up to date.
One detail that can easily be overlooked is that, when creating a new branch, we start from the branch we are currently on, which may be a feature branch rather than the main branch. This means we may unintentionally include changes from other developments without realising it.
It is therefore worth checking the source branch and ensuring it is up to date before starting any new development. This helps prevent conflicts and problems further down the line.
What if you need to roll back?
Even with a well-defined CI/CD process, problems can arise after a change has been deployed. It is therefore important for the team to know how to restore a previous version, in a process known as a rollback. When the problem relates to a change already committed to Git, the team can consult the commit history in Azure Repos or GitHub, identify the change that caused the issue and use the Revert option. This operation creates a new commit that reverses the changes introduced by the selected commit, without deleting the project’s history.
The Fabric workspace can then be updated with the corrected version and, if the problem has already reached Production, that version must go through the deployment process again. If the change was made directly in the workspace and has not yet been pushed to Git, Fabric provides the Undo option, which allows users to return to the last synchronised state.
However, this process requires some care. Restoring a previous version of reports or semantic models does not automatically restore the data, settings or all environment dependencies. Whenever possible, recovery should be tested in a separate environment before reaching Production. This way, rollback becomes a familiar, well-prepared procedure rather than a last-minute attempt to fix a problem.
Licensing, capacity and other options
Before implementing Git integration in Microsoft Fabric workspaces, it is important to check the licensing available within the organisation. This feature is available in workspaces associated with a Microsoft Fabric capacity (F SKUs, starting from F2) or a Power BI Premium per capacity licence (P SKUs, such as P1, P2 and P3), provided the platform requirements are met. It can also be tested using a free Fabric Trial capacity.
Individual Power BI Pro and Premium Per User (PPU) licences do not, on their own, replace this capacity, although they are still required for developers to create and manage Power BI content in shared workspaces. In addition to licensing, the organisation must enable Git integration and assign the appropriate permissions to users. The connection can be made to either Azure Repos or GitHub, with the latter offering an alternative that does not remove the Fabric capacity requirements.
What to try first
For a pilot project, it is worth testing synchronisation in both directions, understanding how conflicts arise and are resolved, checking connections between environments and rehearsing
the restoration of a previous version. These are all scenarios the team should be familiar with before relying on the process in Production.
Changes to the working methodology
Another important aspect is understanding that adopting this methodology changes the way reports are delivered to end users. With a CI/CD process in Power BI and Fabric, publishing is no longer a manual, individual step. Instead, it follows a defined workflow: development in a branch, review, integration and automated deployment between environments.
For this model to work, everyone involved must understand the process and follow it consistently. It is not possible to publish a report through the pipeline one day and directly from Power BI Desktop the next. Every exception break traceability, creates discrepancies between the repository and what is running in Production, and undermines the benefits that motivated the change in the first place.
Adopting CI/CD in Power BI does not mean making work more complicated by introducing additional tools. It means being able to develop collaboratively, understand what has changed and deploy with greater confidence. PBIP, TMDL and PBIR make changes easier to track. Git integration brings the repository closer to Fabric workspaces, while deployment options allow teams to choose how each version is delivered.
The best starting point is a small project: save it as PBIP, connect it to Git, experiment with synchronisation using a development workspace and test a change from beginning to end. Then, depending on the team’s needs, code reviews, separate environments and automation can be introduced. The process should evolve as required, without losing its simplicity.