Prepstellar

DP-600 · Workspace Development Lifecycle

23 cards

Power BI Desktop Projects

Swipe, scroll or use ← →
  1. Save the work as text, not as a binary

    A Power BI Desktop project, identified by the .pbip extension, saves a report and its semantic model as plain text files in a folder structure. This differs from a .pbix file, which stores the content as a single binary file.

    The consequence is immediate. The text-based project format lets standard diff tools expose changes such as a renamed column, a modified DAX measure, or an added relationship.

    1 / 23
  2. Save the work as text, not as a binary

    Saved as What a reviewer can see
    .pbix binary file That the file changed
    .pbip project folder Which column, measure, relationship, page, or visual changed

    "The file changed" is not a review. Being able to name the change is what makes review, approval, and history worth having, and naming it is exactly what the format buys.

    2 / 23
  3. Quick check

    How does a Power BI Desktop project store a report and its semantic model?

    1. AAs a single binary file that tools read as one opaque blob

      That describes the `.pbix` format, which is the binary alternative this format replaces.

    2. BAs plain text files in a folder

      Right. Readable text in a folder structure is what lets standard diff tools compare versions.

    3. CAs cached data held inside a repository branch until it is published

      A project is a local save format, and nothing is cached inside a branch on the author's behalf.

    3 / 23

  4. Learn the two folders

    A project has two main subfolders, and each holds a different kind of definition.

    The <name>.SemanticModel folder contains the semantic model definition in Tabular Model Definition Language, or TMDL. TMDL stores each table, measure, and relationship in a separate readable text file.

    4 / 23
  5. Learn the two folders

    The <name>.Report folder contains the report definition in Power BI Report format, or .pbir. A .pbir file is a JSON document that represents report pages, visuals, and layout as structured text.

    Folder Format What it defines
    <name>.SemanticModel TMDL Tables, measures, relationships
    <name>.Report .pbir, JSON Pages, visuals, layout

    Keeping them apart is what lets a reviewer tell a modeling change from a presentation change at a glance, before reading a single line.

    5 / 23
  6. Quick check

    What do the two main subfolders of a project hold?

    1. ABoth hold JSON page definitions, one copy for authors and one for reviewers

      Only the report definition is JSON, and a project keeps no duplicate copies for different readers.

    2. BBoth hold the branches and commits belonging to the repository

      Branches and commits live in the repository, not inside the saved project folders.

    3. CThe semantic model folder holds TMDL; the report folder holds `.pbir`

      Right. One folder defines tables, measures, and relationships; the other defines pages, visuals, and layout.

    6 / 23

  7. Create the project

    To create the project, select File, then Save as in Power BI Desktop and choose Power BI Project (.pbip) as the file type. Power BI Desktop creates the project folder structure and a .gitignore file.

    Two things arrive together: the folders that hold the definitions, and a file that decides what should never be committed alongside them.

    7 / 23
  8. Create the project

    It is worth contrasting that path with its neighbors, because they all start somewhere similar:

    What you want Where you go
    A text-based project folder File, Save as, Power BI Project
    A reusable report structure without data File, Export, Power BI template
    A promotion path between environments Workspaces, Deployment pipelines

    Only the first produces a folder that a repository can review line by line.

    8 / 23
  9. Quick check

    Which Power BI Desktop sequence saves a project?

    1. AFile, then Save as, choosing Power BI Project as the file type

      Right. Power BI Desktop then creates the project folder structure along with a `.gitignore` file.

    2. BFile, then Export, then template

      Exporting a template produces a reusable report structure without data, not a text-based folder.

    3. CWorkspaces, then Deployment pipelines

      That path builds a promotion route between workspaces and saves nothing locally.

    9 / 23

  10. Keep your progress in the app

    That’s 3 of 9 quick checks. In the app they stay answered, and every lesson remembers where you left off.

  11. Turn on the preview option first

    The project save option is captured as a preview feature. Enable it through File, Options and settings, Options, Preview features, and then Power BI Project (.pbip) save option before saving a project.

    This explains the most common first stumble: the file type is simply not in the Save as list, and no amount of looking will find it until the preview feature is switched on.

    It is a setting on that installation of Power BI Desktop. A workspace setting will not produce it, and neither will a pipeline or a repository.

    10 / 23
  12. Quick check

    The project file type does not appear in Save as. Where is it enabled?

    1. AWorkspace settings, then Git integration

      Git integration connects a workspace to a repository in the service and changes no local save option.

    2. BDeployment pipelines, then deployment rules, then the data source option

      Deployment rules replace configuration values between stages and have no effect on local file types.

    3. COptions and settings, then Options, then Preview features

      Right. The save option is a preview feature, so it is switched on there before a project can be saved.

    11 / 23

  13. Let the ignore file do its job

    Saving a project also produces a .gitignore. The generated .gitignore excludes cache and local settings files from version control.

    That is exactly the right split. Cache files and local settings describe one machine and one session: they change constantly, they mean nothing to a colleague, and they would bury the changes that matter under noise.

    What it does not exclude is the part you want reviewed. The model definition and the report definition stay in version control, because they are the content.

    12 / 23
  14. Quick check

    What does the `.gitignore` created with a project do?

    1. AIt keeps the model definition files out of every commit

      The model definition is the part most worth versioning, so it is not excluded.

    2. BIt excludes cache and local settings files

      Right. Those files are machine-specific, so they stay out of version control.

    3. CIt stops the workspace from synchronizing with the repository

      Workspace synchronization is configured in the service and is unaffected by a local ignore file.

    13 / 23

  15. Review changes as text

    Because project definitions are text files, authors can inspect exact differences between versions instead of seeing an opaque binary change. This makes code review practical: reviewers can identify which measures, columns, relationships, pages, visuals, or layouts changed.

    A pull request stops being an act of trust and becomes something a colleague can actually read.

    14 / 23
  16. Review changes as text

    Picture a review where someone says they renamed one column. With a binary file, the reviewer can confirm that the file changed, and nothing more. With a project, the difference shows the renamed column in its own file — and shows whether a visual quietly changed as well.

    That second half is the real gain. Readable definitions surface the changes nobody mentioned just as reliably as the ones they did.

    15 / 23
  17. Quick check

    Why can a reviewer tell that a change renamed a column rather than altering a visual?

    1. ABecause each table, measure, and relationship is a separate readable text file

      Right. Text definitions let ordinary diff tools show exactly which measures, columns, relationships, pages, visuals, or layouts changed.

    2. BBecause the binary report file records the change

      A binary file shows that something changed without showing what, which is the problem this format solves.

    3. CBecause comparison icons mark the item orange

      Stage comparison icons say an item differs between environments; they do not describe the change.

    16 / 23

  18. Edit the model definition with a script

    The TMDL semantic model definition also supports programmatic editing. A script or another tool can apply a batch update directly to the TMDL files, such as adding a description to every measure, and the resulting text changes can then be committed through Git.

    Text is what makes that possible. A script can open and rewrite a definition file; it cannot do the same to a binary report.

    17 / 23
  19. Edit the model definition with a script

    The pattern is worth remembering as two steps:

    1. A script edits the model definition files in place.
    2. The resulting text changes are committed and reviewed like any other change.

    Nothing about the second step is special, and that is the point. A bulk edit made by a script arrives in review looking exactly like a bulk edit made by a person, and it can be judged the same way.

    18 / 23
  20. Quick check

    A team must add a description to every measure and then review the result as text changes. What fits?

    1. AOpen the binary report file and edit each measure by hand before deploying it

      A binary file cannot be batch-edited or read line by line, and deploying produces no reviewable change.

    2. BUpdate the TMDL files with a script, then commit

      Right. The model definition supports programmatic editing, and the text changes are then committed.

    3. CChange a deployment rule for the stage, then resave the report from the service

      Deployment rules override configuration values between stages; they write nothing into a model.

    19 / 23

  21. From desktop to repository to workspace

    A team workflow can combine local project authoring with a shared repository and a Fabric workspace. Authors iterate locally in Power BI Desktop, commit the .pbip files to Git, and review readable changes there. The Fabric workspace then synchronizes with the repository so its published content reflects the latest commits.

    Step What it supplies
    Author locally in a project Readable local artifacts
    Commit to the repository Version history and collaboration
    Synchronize the workspace Published content matching the commits

    In this sequence the project format supplies readable local artifacts, Git supplies version history and collaboration, and workspace Git synchronization brings committed content into the service.

    20 / 23
  22. Quick check

    Authors work locally and the Fabric workspace must reflect approved commits. Which sequence matches?

    1. AEdit the binary file, deploy to Test, then create a repository

      That leaves version history until last, so the readable review the team wanted never happens.

    2. BEdit a deployment rule, save the layout, then clear the local cache

      None of those steps produces a reviewed change or brings committed content into the workspace.

    3. CEdit the project locally, commit it to Git, then let the workspace synchronize with the repository

      Right. Readable local artifacts, then history and collaboration, then published content that matches the commits.

    21 / 23

  23. Key takeaways

    • A .pbip project stores report and semantic model definitions as text, unlike the binary .pbix format.
    • The SemanticModel folder uses TMDL for tables, measures, and relationships, while the Report folder uses JSON-based .pbir for pages, visuals, and layout.
    • Save through File, Save as, Power BI Project, after enabling the preview option under Options, Preview features.
    • Saving a project creates a .gitignore that excludes cache and local settings files from version control.
    • Text pays off twice: reviewers can name what changed, and scripts can batch-edit the model definition before those changes are committed.
    22 / 23
  24. Quick check

    Which statement about the project format is correct?

    1. AIt stores definitions as text, so ordinary diff tools can review them

      Right. Readable text is the whole reason the format supports code review and scripted edits.

    2. BIt stores one binary file

      A single binary file is the `.pbix` alternative, and it is what this format replaces.

    3. CIt stores report pages in the semantic model folder and measures in the report folder

      The folders are the other way around: model definitions in one, report definitions in the other.

    23 / 23

  25. 9 quick checks · then the test

    In the app, finishing the quick checks opens this lesson’s 10-question test, and the ones you miss come back exactly when you’re about to forget them.

The whole course, on your phone

Lessons you can read, audio you can listen to on the way to work, and practice that remembers what you got wrong.