Power BI

Embedded Personalized Power BI Reports

By Gunjan Kanani November 13, 2026 12 min read

Enabling Users to Create, Edit, and Share Their Own Reports 

Most dashboards in a business app are built once, by a developer, and then just sit there. If a user wants the numbers sliced differently, they file a ticket and wait for a release. It works, but it doesn’t scale – and it doesn’t feel like “your” data. Here’s how we let business users build, edit, and share their own Power BI reports directly in the browser, without a developer, without Power BI Desktop, and without a Microsoft login screen. 

The Problem We Started With 

Reports in the app used to be fixed and developer-provisioned. Someone built a report in Power BI Desktop, published it, registered it centrally, and shipped it in a release. Business users could look at it – but couldn’t touch a visual, add a page, or build anything of their own. Every new report idea became a development ticket. 

The goal was self-service BI: let a business user build a report against data the business already governs, without installing anything and without a Power BI login of their own. 

The Solution: One Application Identity, Not One License Per User 

The fix isn’t to give every user a Power BI account. That gets expensive fast, and now IT is managing Microsoft accounts for people whose job has nothing to do with Microsoft accounts. 

Instead, we use Microsoft’s “App Owns Data” embedding model. A single application identity – not the end user – authenticates to Power BI and does everything on the user’s behalf. 

  • No per-user license: store admins, advisors, and managers need no Power BI license and no Microsoft account at all. 
  • Cost scales with usage, not headcount: adding a hundred new users adds no licensing cost. 
  • One identity to manage: only the application’s own identity needs to exist in the Microsoft tenant. 

Setting this up is a one-time platform task, not something repeated per user: 

  1. Register an application identity in Azure AD and issue it a client secret. 
  1. In Power BI’s tenant settings, allow that application identity to call the Power BI APIs. 
  1. In every workspace the feature needs to reach, add the application identity as a Member or Admin – read-only access isn’t enough, since the app has to create and save reports, not just view them. 

Production note 

This embedding model needs a dedicated Power BI capacity (an Embedded A SKU, or Premium/Fabric) assigned to the workspaces in use. Development and testing work without one, on a limited free quota. 

How Users Skip the Microsoft Login Entirely 

This is the part people usually ask about first: how does someone get a fully editable Power BI canvas without ever seeing a Microsoft sign-in prompt? 

The answer is that the user is simply never part of that authentication exchange. Two identities exist side by side and never cross paths: 

  • The user’s identity is handled entirely by our own application’s login. It’s used only to decide which reports someone is allowed to open – it’s never sent to Power BI. 
  • The application’s identity authenticates to Power BI server-to-server, using Azure AD, and never touches the browser. 

What the browser actually receives is a narrow, purpose-built credential, not a login session: 

  • Valid for one hour, then it dies. 
  • Scoped to one specific report and dataset, in one named workspace. 
  • Grants no access to any other report, workspace, or admin function. 
  • Carries no user identity, so it can’t be replayed as a person. 

Even if it were intercepted, it’s a narrow key to a single door – not a master key to the account. 

Solving the “Report Doesn’t Exist Yet” Problem 

One design wrinkle made this harder than a simple “issue a token” approach: the moment a user starts building a brand-new report, that report doesn’t exist yet, so there’s nothing to scope a credential to. The solution was to issue two different kinds of credentials, depending on the moment. 

Creating something new 

A create credential is scoped only to a dataset and its workspace – no report id, because none exists. It opens a blank authoring canvas with full rights to design freely. When the user saves, Power BI creates a brand-new report and hands back its identifier. 

Editing something that exists 

An edit credential is scoped to a specific report and the dataset behind it. It opens the canvas in edit mode, and whether “Save” is available depends on whether the user owns that report. 

Re-issuing after every save 

Right after any save – a first creation or a Save As – a new report now exists that the previous credential doesn’t cover, since credentials are tied to named artifacts. The application immediately requests a fresh credential for that new report and moves the user onto it, so editing continues without a visible interruption. This is also what makes a Save As copy indistinguishable from a report built from scratch – both end on the same re-issue step. 

Making Sharing Safe: One Report, Two Permission Levels 

Sharing needed to let a colleague build on someone’s report without being able to silently overwrite it. The solution turned out to be simpler than expected: Power BI can embed the very same report with two different permission levels. 

  • The owner gets full rights – Save overwrites the original, and Save As creates a copy. 
  • A share recipient gets copy-only rights – Power BI doesn’t even render a Save button, so overwriting the original is physically not offered, not just hidden by convention. 

Sharing itself doesn’t duplicate anything. It simply grants a second person access to the same underlying report, so an update from the owner is instantly visible to everyone it was shared with – no syncing, no stale copies. If a recipient wants their own editable version, Save As creates a genuinely new report that they now own outright, free to diverge from the original. 

Unsharing doesn’t erase history either – it deactivates access, so the report disappears from the recipient’s list immediately while the record of who had access, and when, is preserved for audit. 

Keeping Data Governance Intact 

Letting users build their own reports could easily mean losing control over who sees what data. That risk is handled by resolving workspace access fresh on every visit, from three things combined: 

  1. What the user’s role permits – an admin reaches far more business areas than a store advisor. 
  1. Which registered report areas match that role, each pointing to a workspace. 
  1. Any workspace where the user already owns or was shared a report, so a shared report is never filtered away just because the recipient’s role wouldn’t normally reach that workspace. 

The app then checks that list against what the application identity can actually see in Power BI, and only the overlap is shown. A user can never build against data their role doesn’t already permit. 

Adding a new workspace later is just as lightweight: publish the dataset, grant the application identity Member or Admin rights on it, and register it against the right role category. No code change, no release. 

The Everyday Flows 

Creating a report 

A user opens Personalized Reports and sees two sections: My Reports (what they own or were given) and Create Reports (datasets their role permits). They pick a dataset, hit Create, build visuals exactly as they would inside Power BI itself, and save. The new report immediately appears in their My Reports, owned by them. 

Editing and deleting 

Opening one of their own reports issues a full edit credential and Save overwrites it directly. Deleting is guarded the same way access is: the server re-verifies ownership before deleting anything, and flatly refuses to delete a report that was only shared with the user, never created by them. 

Sharing 

Only an admin sees the Share control, and – importantly – that restriction is re-checked on the server, not just hidden in the interface. Hiding a button is a convenience; the actual security decision is made server-side every time. 

Under the Hood: How the Integration Actually Works 

Everything above explains the design. This section is the implementation behind it – the actual authentication call, the actual token request, and the actual flags that decide what a user can do inside the canvas. 

Step 1 – The server authenticates as the application, not as the user 

Our own application login (the one end users see) is completely separate from what talks to Power BI. A second, independent authentication happens entirely server-side, using Microsoft’s MSAL library, with no user involved at all: 

ConfidentialClientApplicationBuilder 
    .Create(clientId)              // Azure AD App Registration’s Application ID 
    .WithClientSecret(secret)      // the App Registration’s client secret 
    .WithAuthority(tenantUrl)      // https://login.microsoftonline.com/{tenantId} 
    .Build() 
    .AcquireTokenForClient(scope)  // OAuth2 client-credentials grant – no user involved 
    .ExecuteAsync() 

The scope requested is fixed by Microsoft, not something we chose: https://analysis.windows.net/powerbi/api/.default – the exact string that grants Power BI REST API access to an application identity rather than a signed-in person. 

Step 2 – The server mints the actual credential the browser uses 

Once authenticated, the server calls one specific Power BI SDK method – the “Generate Token v2” endpoint – to produce the short-lived credential handed to the browser: 

PowerBIClient.EmbedToken.GenerateTokenAsync(GenerateTokenRequestV2 request) 

What goes into that request object is what actually decides what the token is good for: 

  • Datasets – always required: the target dataset for Create, or the report’s dataset for Edit. 
  • Reports – left empty for Create (no report exists yet), set to the specific report id for Edit. This is the core reason Create and Edit need separate token calls. 
  • TargetWorkspaces – the workspace, required in both cases. 
  • Identities – deliberately left null. No Row-Level Security identity is attached, since the design intentionally applies no per-user data filtering (see the operational notes below). 
  • LifetimeInMinutes – set to 60. The token expires in one hour no matter how long the tab stays open. 

Step 3 – A single number decides Save vs. Save As vs. Create 

This is the actual mechanism behind report sharing, and it lives entirely in the browser-side SDK, not on the server. The powerbi-client JavaScript SDK reads a permissions value out of its embed configuration, and that value is a bitmask: 

  • Read (0): view only. 
  • ReadWrite (1): can overwrite the report – this is the bit that turns on the Save button. 
  • Copy (2): can Save As a new copy. 
  • Create (4): can author a brand-new report. 
  • All (7): ReadWrite + Copy + Create combined – literally the sum of the other three. 

So the owner of a report is embedded with permissions = 7, which includes the ReadWrite bit – Save is available. A share recipient is embedded with permissions = 2 (Copy) alone. The ReadWrite bit is simply absent, so the SDK doesn’t render a Save button at all – Save As is the only option, because that’s the only bit that was set. Nothing checks this at the moment someone clicks Save; the button either exists or it doesn’t, based entirely on which bits were sent down at embed time. 

Step 4 – Two different SDK calls, depending on whether the report exists 

The JavaScript embedding itself is invoked differently depending on the mode: 

  • powerbi.createReport(container, config) – used for a brand-new report. No report id is passed, because none exists. 
  • powerbi.embed(container, config) – used for every edit flow, own or shared. Requires the report id, and the permissions + viewMode values together decide what chrome (Save, Save As) actually renders. 

The four things that live outside our code entirely 

None of the above works unless four permissions are granted in Microsoft’s own admin consoles – not in our application, and not fixable by writing more code: 

  1. An Azure AD App Registration exists, with a valid, non-expired client secret – this is the service principal our server authenticates as. 
  1. In the Power BI Admin Portal, “Allow service principals to use Power BI APIs” is enabled, with our service principal on the allow list. Skip this and authentication succeeds but every Power BI API call afterward is rejected. 
  1. The service principal is added to each relevant workspace as Member or Admin. Contributor is not enough – it can’t create reports or issue create/edit tokens. 
  1. A dedicated Power BI capacity is assigned to the workspace for production use. Without it, embed sessions are limited to a small free development quota. 

Troubleshooting tip 

If Create, Edit, or Share suddenly stops working and nothing changed in the application’s own code, check these four external settings first – most often it’s #3, a workspace membership edited directly in Power BI without the change being communicated back to the development team. 

Security, in One Sentence 

The guiding principle behind all of this: every restriction visible in the interface has a matching check on the server. Whether it’s who can share, who can delete, or whether Save overwrites or copies, the authoritative decision is never left to the browser – so a user can’t gain access simply by manipulating the page. 

What This Actually Solves 

Put together, this design gets self-service BI without the usual trade-offs that come with it: 

  • Business users get a real report-building experience, not a locked-down viewer. 
  • IT doesn’t manage a growing list of Power BI licenses or Microsoft accounts. 
  • Data governance stays exactly where it was – role-based, and enforced server-side. 
  • Sharing is instant and always current, because there’s only ever one underlying report. 

Reports that used to be development tickets are now something a user builds in an afternoon – and shares with a click. 

Leave a Comment

Your email address will not be published. Required fields are marked *

Your email will not be published.

Chat on WhatsApp Call Us Now