Power BI customers demand enterprise BI solutions that scale to all users across the largest organizations. This depends on enabling team collaboration and automation of deployments across development, test, and production environments to meet the needs of mission-critical BI systems. We are thrilled to announce the public preview of Power BI Desktop Developer Mode, taking advantage of Microsoft’s deep heritage in enterprise BI, and bringing Pro BI developer experiences right into Power BI Desktop.
As the first feature of Developer Mode, Power BI Desktop now lets you save your work as a Power BI Project (PBIP). When saving as a project, report and dataset artifact definitions are saved as individual plain text files in a simple, intuitive folder structure.
Storing dataset and report metadata as text files enables capabilities such as:
- Source Control: Power BI artifact definitions can be stored in a source control system, typically Git. Allowing developers to track version history, compare different revisions (diff), and revert to previous versions. Source control will also unblock co-development and collaboration using Power BI Desktop, by leveraging familiar collaboration mechanisms for resolving conflicting changes (merge) and reviewing changes (pull requests).
- Continuous Integration and Continuous Delivery (CI/CD): Customers can setup systems where developers submit a proposed change to the CI/CD system, and the system subjects the change to a series of quality gates before applying the change to the production system. The quality gates may include things like reviews by other developers (code review) and automated testing.
- Text Editor Support: Artifact definition files for datasets and reports must be text files, publicly documented and human readable. Allowing developers to use code editors (like Visual Studio Code) for more productive authoring (e.g., batch edits).
- Programmatic generation and editing of artifact definitions: Customers can write scripts or applications to make changes to the definition of various artifacts. These applications may be based on public documentation of the artifact definitions and/or libraries provided by Microsoft.
Watch the recording of the Empower every BI professional to do more with data session at Microsoft Build for an end-to-end demonstration of Power BI Desktop Developer Mode together with Fabric Git Integration:
Saving as Power BI Project
Using Power BI Desktop, open a PBIX file and select File > Save As, on the "Save As" dialog pick a folder in your file system and choose the file type "Power BI project files (*.pbip)":
When you save as a project, Power BI Desktop saves report and dataset artifacts as folders, each containing text files that define the artifact. You see the following:
Let's take a closer look at what you see in your project's root folder:
- \<project name>.Dataset folder
- A collection of files and folders that represent a Power BI dataset. It contains some of the most important files you're likely to work on, like model.bim
- Learn more about dataset folder here.
- \<project name>.Report folder
- A collection of files and folders that represent a Power BI report. The most important file is the "report.json" although during Preview external modifications to this file are not supported.
- Learn more about report folder here.
- <project name>.PBIP file
- The PBIP file contains a pointer to a report folder, opening a PBIP opens the targeted report and model for authoring.
- Learn more about PBIP file here.
- .gitIgnore
- Specifies intentionally untracked files Git should ignore, only metadata should be stored at Git Repo. Data is saved as a local cached copy, called cache.abf, that trend to be a large binary file and therefore ignored by Git.
Learn more about Power BI Projects at https://learn.microsoft.com/power-bi/developer/projects/projects-overview.
Multiple Reports and Datasets at same folder
Like in the Service, you have the flexibility to work with multiple reports and datasets within the same folder. This can be done by either saving other PBIX files as PBIP to the same folder or by duplicating the folder to commence the development of a new report or dataset.
The PBIP is optional, only serves as a shortcut to open the report. However, you can always open the report by navigating to the report folder and directly opening the "definition.pbir" file.
When duplicating folders, and if you want to use Fabric Git Integration, don't forget to update the LogicalId at config file and DisplayName at metadata file.
Open a Power BI Project
You can open Power BI Desktop from the Power BI Project folder either by opening the <project name>.pbip file or the definition.pbir file at the report folder. Both options open the report and the dataset for editing.PBIP
PBIR
Editing Power BI Desktop project files
Power BI Desktop developer mode is premised on enabling developers to utilize code editors for editing metadata files.For all project metadata files that support external editing, there is a corresponding public JSON Schema. This schema not only describes all the available properties but also enhances the editing experience in code editors like Visual Studio Code. It provides features such as IntelliSense and validation.
On the documentation page of the dataset and report item folder, you can discover the links to the schemas for each file.
Learn more about the JSON Schemas and how to configure Visual Studio Code at https://github.com/microsoft/powerbi-desktop-samples/tree/main/item-schemas
Source Control with Git
The primary goal of a Power BI project is to facilitate source control by saving your Power BI Desktop development as a folder and text files. In this regard, Git is an excellent choice to accomplish this goal.If you are new to Git, please refer to the following training courses to learn the basics:
- Introduction to Git - Training | Microsoft Learn
- Use Git version-control tools in Visual Studio Code - Training | Microsoft Learn
- Collaborate with Git - Training | Microsoft Learn
- Branching and merging in Git - Training | Microsoft Learn
Create a local Git repo by opening the Power BI Project folder using VS Code:
Click on the "Source Control" option and select "Initialize Repository":
Enter a message and do an initial commit:
From now on, any changes you make in Power BI Desktop changes a file in the folder tracked by your local Git. For example, in Power BI Desktop, when you change a DAX formula for a measure and then save, it triggers a Git diff on the model.bim file. Same thing if you create a new report page, it triggers a Git diff on the report.json file.
By working with a local Git repo, you reap immediate benefits such as:
- Backup and quick recovery of previous versions
- Track changes:
Deep_dive_into_Power_BI_Desktop_Developer_Mode_Preview
- Experimentation, create branches for experiments and new features without compromising the stability of the project:
Deep_dive_into_Power_BI_Desktop_Developer_Mode_Preview
Co-development with Azure DevOps
By connecting your local Git repo to a remote Git host, like Azure DevOps, you can unlock collaborative co-development experiences within the Power BI development environment. This enables multiple individuals to work together seamlessly on the same Power BI project.
In Azure DevOps, select an existing organization or create a new one and create a new Project within the organization:
Select Repos > Files, and then copy the URL of the remote repo:
At VS Code > Source Control > Remote, select Add Remote and Publish the branch:
VS Code takes care of publishing your project into Azure DevOps, where you can see your project files:
Now you can have multiple developers working on the same Power BI project. All they need to do is be synced with the same Azure Devops Git Repo.
Learn more about Azure DevOps and Power BI Projects at https://learn.microsoft.com/power-bi/developer/projects/projects-azdo.
Continuous Integration with Fabric Git Integration
Microsoft Fabric has introduced Git integration with Azure DevOps, allowing you to connect your workspace to Azure DevOps by configuring your Azure DevOps organization, project, repository, and branch in the workspace settings.
Once the connection to an Azure DevOps branch is established, Fabric will monitor and track changes between the Workspace and Git. Whenever a difference is detected, users with appropriate permissions can initiate a synchronization process to ensure that both locations contain the same content. This ensures consistency and harmony between the Workspace and Git, allowing for smooth collaboration and development.
By integrating Azure DevOps and Microsoft Fabric, developers gain the ability to seamlessly sync their Power BI workspaces with Git repositories, ensuring consistency and facilitating continuous integration workflows. This integration allows you to commence your report development in Power BI Desktop, seamlessly transition to the Service, and return to Power BI Desktop, where every modification is securely backed up and versioned by Git.
Learn more about Microsoft Fabric Git Integration at https://learn.microsoft.com/fabric/cicd/git-integration/intro-to-git-integration.
What's Next?
As Power BI Desktop "Developer Mode" continues its journey towards General Availability, several exciting developments are on the horizon:- Datasets will be saved as Tabular Model Definition Language (TMDL).
- Reports will be saved with a new format, that will be source-control friendly and publicly documented.
- New Fabric REST APIs to deploy dataset and report definitions, letting you build complex and dynamic CICD pipelines.