The F64 Question: When Free Power BI Viewers Actually Save You Money

The scenario: a growing reporting audience

You’ve got:

• A core BI team of 8 developers and data engineers
• About 60 business analysts who build and share ad‑hoc reports
• A fast-growing group of 250+ business users who only need to view reports
• A Fabric tenant already in place for data engineering and lakehouse work

Today, you’re roughly here:

• Developers and analysts: mostly on Power BI Pro
• Business users: some Pro, some using shared links, some still on exported Excel/PDF
• IT is being asked to “just buy more Pro licences” as adoption grows

Finance is pushing back: “We’re already paying for Fabric. Why are we buying so many Pro licences just so people can look at dashboards?”

This is the F64 question.

What F64 actually gives you for Power BI viewing

First, what matters for this discussion is Power BI in Fabric and how capacities interact with viewer licences.

As of late 2024, the relevant pieces are:

• Fabric capacity (F SKUs)

  • You can host Power BI items (datasets, reports, semantic models) on Fabric capacities.
  • F64 is a mid‑range capacity with more CPU and memory than lower F SKUs, intended for heavier workloads and larger audiences.

• Free Power BI users (Power BI “free” licence)

  • In a Fabric tenant, free users can view content that is hosted on a Fabric capacity, provided they have access (via app, workspace, or sharing) and the tenant settings allow it.
  • They cannot publish to shared workspaces and have limited authoring capabilities, but for consuming reports and dashboards in apps, they are fully viable.

• Power BI Pro users

  • Needed for publishing and collaboration in workspaces not backed by Fabric or other Premium capacity.
  • Also needed if you rely on Pro-only sharing patterns (e.g. share report directly from My workspace without capacity).

The key behavioural point:

If your Power BI content is hosted on a Fabric capacity (such as F64) and your tenant is configured appropriately, free users can view that content without requiring Pro licences.

This is the mechanism that lets you trade a monthly capacity cost for a large pool of free viewers.

The baseline: what you’re probably paying now

Let’s anchor the scenario in numbers you can adjust.

Assume:

• 8 BI developers/data engineers
• 60 business analysts who publish and share reports
• 250 business users who primarily view reports

Without Fabric capacity, a common pattern is:

• All 68 creators (8 + 60) have Power BI Pro
• Many or all of the 250 viewers end up with Pro over time, because:
  • You want them to access apps and shared reports without friction
  • You don’t want to maintain parallel exports

You quickly drift towards:

• 318 Pro licences (68 creators + 250 viewers)

The total monthly cost is simply:

• 318 × Pro_unit_price
  (keep this as a variable; you’ll plug your actual rate into the spreadsheet)

The important part is the shape of the cost: it grows linearly with the number of viewers.

The F64 model: capacity plus a smaller Pro core

Now switch to a Fabric‑centric model:

• You buy one F64 capacity for your tenant.
• You move your shared Power BI content (apps, production workspaces) onto that capacity.
• You keep Pro licences only for people who create and manage content.

In the scenario:

• 8 BI developers/data engineers → stay on Pro
• 60 business analysts → mostly stay on Pro (they publish and iterate reports)
• 250 business users → move to Power BI free and view reports on the F64 capacity

You’re now paying for:

• 68 Pro licences (for creators)
• 1 F64 capacity

Total monthly cost:

• 68 × Pro_unit_price + F64_unit_price

The key difference: the cost for viewers is now flat with respect to their count, as long as the F64 capacity has enough headroom for your usage.

The break-even maths in plain terms

Let’s formalise the F64 question.

Define:

• C_pro = monthly cost of one Power BI Pro licence
• C_F64 = monthly cost of one F64 capacity
• N_creators = number of people who genuinely need Pro
• N_viewers = number of people who only need to view content

Model 1: Pro everywhere

Everyone gets Pro:

• Total cost = (N_creators + N_viewers) × C_pro

Model 2: F64 plus free viewers

Only creators get Pro, viewers are free on capacity:

• Total cost = N_creators × C_pro + C_F64

The break-even point

We want the point where Model 2 becomes cheaper than Model 1:

N_creators × C_pro + C_F64  <  (N_creators + N_viewers) × C_pro

Rearrange:

N_creators × C_pro + C_F64  <  N_creators × C_pro + N_viewers × C_pro
C_F64                       <  N_viewers × C_pro
N_viewers                   >  C_F64 / C_pro

The number of viewers at which F64 pays for itself depends only on the ratio C_F64 / C_pro.

If that ratio is around 180 in your commercial terms, then:

• Once you have more than ~180 pure viewers, a Fabric F64 capacity plus free viewers is cheaper than giving those viewers Pro.

In practice, many organisations see a ratio in that ballpark, which is why “above roughly 180 viewers, F64 pays for itself” is a useful mental anchor. But you should plug your own prices into the formula.

A quick Excel model

You can drop this into Excel to make it concrete.

=LET(
    C_pro,      <your_Pro_monthly_price>,
    C_F64,      <your_F64_monthly_price>,
    N_creators, 68,
    N_viewers,  250,
    Cost_ProOnly,   (N_creators + N_viewers) * C_pro,
    Cost_F64Model,  N_creators * C_pro + C_F64,
    BreakEvenViewers, C_F64 / C_pro,
    CHOOSE(1,
        "Cost with Pro for everyone: " & Cost_ProOnly & CHAR(10) &
        "Cost with F64 + free viewers: " & Cost_F64Model & CHAR(10) &
        "Break-even viewer count: " & BreakEvenViewers
    )
)

Replace the two price placeholders with your negotiated monthly prices. The BreakEvenViewers result is the number that matters in the budgeting discussion.

Capacity reality check: can F64 handle your viewers?

The maths only helps if the capacity can carry the load.

Before you recommend F64, you need a technical sanity check:

1. Usage profile

   • How many concurrent report viewers do you expect at peak times?
   • How heavy are your semantic models (dataset size, complexity, DirectQuery vs Import vs Direct Lake)?

2. Existing workloads on Fabric

   • Are you already running heavy lakehouse, data engineering, or data science workloads on the same capacity?
   • Do you plan to isolate BI workloads on a dedicated capacity or share with other Fabric workloads?

3. Performance expectations

   • Business users expect reports to load promptly, especially at scale.
   • If you under‑size capacity, you’ll trade licence savings for user frustration.

Within Fabric, you can monitor capacity metrics (CPU, memory, query wait times) to see if F64 is coping:

• If you see sustained high CPU and query delays at peak times, you may need:
  • To optimise models (reduce cardinality, simplify measures, tune relationships)
  • To split workloads across capacities
  • Or to move to a higher capacity SKU

The finance conversation needs this caveat: F64 is not magic. It’s cheaper than hundreds of Pro licences only if it can actually serve those viewers without degradation.

Governance and sharing: avoiding Pro creep

Even if the numbers say F64 is cheaper, governance can quietly push you back towards more Pro licences if you don’t adjust how you share content.

Key patterns that keep viewer licences free:

1. Use apps backed by Fabric workspaces

   • Publish production reports into workspaces that are assigned to the F64 capacity.
   • Build Power BI apps from those workspaces and give free users access to the app.
   • Avoid sharing directly from personal workspaces or non‑capacity workspaces.

2. Centralise production content

   • Treat capacity‑backed workspaces as the only place for content that goes to broad audiences.
   • Keep ad‑hoc, experimental content in Pro‑only workspaces.

3. Tenant settings

   • Ensure tenant settings allow free users to consume content on Fabric capacity.
   • Make sure external sharing settings align with licensing expectations.

If you let teams create and share reports from non‑capacity workspaces “because it’s easy”, you will:

• Force viewers to need Pro for those reports
• Undermine the whole F64 economics

The F64 model works best when content destined for large audiences is always on capacity.

How to present this to Finance and IT together

You’ll get better traction if you present the F64 question as a joint decision rather than a licence shopping list.

1. Start with the viewer count and growth curve

• Show current and projected numbers of pure viewers over the next 12–24 months.
• Highlight that viewer numbers typically grow faster than creator numbers.

2. Show the two cost curves

Plot two lines in Excel:

• Line 1: Total_cost_ProOnly = (N_creators + N_viewers) × C_pro
• Line 2: Total_cost_F64Model = N_creators × C_pro + C_F64

As N_viewers increases, the gap between the lines is the saving from moving viewers to free on capacity.

3. Add the capacity constraints

• Explain what F64 is already doing for Fabric workloads.
• Show monitoring data or pilot tests to demonstrate that F64 can handle the expected viewer load.
• Be explicit about what would trigger a move to a higher SKU.

4. Define clear licence policies

Agree on:

• Who gets Pro (creators, admins, a small set of power users)
• Who gets free (everyone else)
• Which workspaces must be on capacity

This turns the F64 question from “should we buy this SKU?” into “how do we control licence creep while keeping performance acceptable?”

Before/after in the scenario

Back to the original team:

Before (Pro everywhere):

• 318 Pro licences
• Mixed sharing patterns, some exports, some report links
• Monthly cost grows every time another department wants access

After (F64 + free viewers):

• 68 Pro licences for creators
• 1 F64 capacity hosting all production Power BI content
• 250+ free viewers consuming reports via apps
• Monthly cost is mostly flat as more viewers join, until capacity limits are reached

Practically, you’ll still have edge cases:

• A few “viewer” users need Pro for occasional self‑service work
• Some departments may want their own workspace governance

But the dominant cost driver — hundreds of pure viewers — now sits on a fixed capacity line instead of a per‑user licence line.

One concrete takeaway

If your viewer count is heading north of 200 and you already run Power BI on Fabric, sit down with Finance and IT and calculate:

BreakEvenViewers = C_F64 / C_pro

If your current or near‑term viewer count is above that number, it’s time to redesign your sharing model around F64 and free viewers, not to keep buying Pro licences by default.