Dataverse Capacity Got Bigger This Year. Your Storage Governance Still Needs to Catch Up

IT director reviewing a Dataverse storage capacity dashboard showing database, file, and log usage

An IT director we spoke with recently pulled up the Power Platform admin center in January expecting the same tired warning banner about Dataverse capacity that had been sitting there since October. It was gone. Database storage for their Dynamics 365 Finance and Supply Chain Management environment had jumped from 90 GB to 125 GB overnight, with no purchase order, no change request, and no email from their partner. The natural conclusion was that the capacity problem had quietly solved itself. Four months later, the same environment tripped a new kind of alert: a file storage overage notice, even though database usage looked flat. Nothing had been deleted or migrated. The ground underneath the numbers had simply moved.

That is roughly where most Dynamics 365 and Power Platform customers stand right now with Dataverse storage. Microsoft raised default capacity entitlements significantly in December 2025, restructured how that capacity is reported and managed, and then made a second, narrower adjustment in the spring that reclassifies certain metadata between storage types. Individually, each change is well documented. Together, they change what a capacity plan built a year ago actually means, and CIOs and IT directors who treat the December Dataverse capacity increase as a problem solved rather than a system redesigned are going to be surprised by their own admin center in a quarter or two.

What changed in Dataverse capacity this December

The default database capacity increase was substantial and varied by product. Copilot Studio, Power Apps per-app plans, and Power Automate process licenses moved from a 5 GB to a 15 GB baseline. Dynamics 365 CRM applications, including Sales, Customer Service, Field Service, and the Contact Center, moved from 10 GB to 30 GB. Dynamics 365 Customer Insights went from 25 GB to 45 GB. On the ERP side, Standard tier products including Finance, Supply Chain Management, Project Operations, Commerce, and Human Resources rose from 60 GB to 90 GB, while the Premium tier for Finance and Supply Chain Management increased from 90 GB to 125 GB. File storage roughly doubled across most of these same products, though Microsoft did not publish the same level of per-product detail it did for database capacity. Log storage was left untouched.

The more structurally important change sits underneath those numbers. Finance and Operations customers previously managed two separate storage pools: one for the Operations database and one for Dataverse. As of December, those pools merged into a single combined entitlement. For an organization that had been carefully tracking two distinct capacity ceilings, this is not a cosmetic simplification. It changes how consumption trends read, and it means a team that spent the last two years building spreadsheets or Power BI reports to track Operations and Dataverse separately needs to rebuild that tracking around a single number.

Three capacity types, not one

Alongside the entitlement increase, Microsoft has been rolling out a new capacity reporting model that separates Dataverse storage into three distinct types: database, file, and log. This is not universal yet. Organizations still on the legacy model see a single blended capacity figure, while those on the new model get per-type visibility along with a mechanism called cross-capacity-type borrowing. Under that mechanism, unused database capacity can offset a log or file overage, and unused log capacity can offset a file overage, but file capacity cannot offset shortfalls anywhere else. A tenant only registers as officially over capacity after all of that eligible borrowing has already been applied.

Abstract illustration of database, file, and log storage blocks connected by data flow lines representing Dataverse capacity

This matters for budget owners specifically because it changes what an overage notification actually tells you. A file storage warning on an environment that appears to have plenty of headroom in its combined number is not necessarily a sign that the tenant needs more storage overall. It may simply mean the tenant has database or log capacity sitting unused that isn’t automatically flowing to cover the file shortfall, either because the environment hasn’t moved to the new model yet or because the borrowing rules genuinely don’t apply in that direction. Before anyone approves a purchase of additional capacity, it is worth confirming which reporting model the tenant is actually on and whether the specific storage type in the alert is one that borrowing rules can even help with.

The April reclassification nobody budgeted for

In April 2026, Microsoft moved solution-aware tables and related metadata out of database storage and into file storage. Total consumption for an organization does not change as a result of this move, but the split between the two numbers does, and it does so without any corresponding change in what the organization is actually storing. A team that set a database utilization threshold as an internal early-warning trigger, say 70 percent of entitlement, may find that number drop for reasons that have nothing to do with actual data growth, while file utilization climbs for the same non-reason. Anyone reviewing a capacity trend line that spans this period without accounting for the reclassification is going to draw the wrong conclusion about whether their data growth rate is accelerating or slowing down.

Sales Premium customers got a further, separate adjustment in the same window: per-user file storage entitlement doubled from 250 MB to 500 MB, and the underlying tenant base storage figures for those environments moved as well. Microsoft’s own framing for these changes has been candid about the driver: AI-assisted features, Copilot experiences inside Dynamics 365 applications, and the broader push toward agentic workflows all generate metadata, context, and interaction history that traditional transactional storage planning never had to account for. Storage capacity planning built around transaction volume alone is now measuring the wrong thing.

What a capacity plan actually needs to do differently

None of this means the December increase was a bad deal for customers. Bigger entitlements at no additional cost are, on their own terms, a straightforward win, and organizations that were previously purchasing supplemental capacity to cover a gap that the new baseline now closes should go back and cancel or right-size that spending. The mistake is treating a larger number as the end of the exercise rather than the start of a different one.

The more durable response is to rebuild storage governance around the actual mechanics Microsoft has put in place rather than around the old assumption of one number that only ever goes up when you buy more. That starts with confirming, environment by environment, whether the tenant is on the legacy single-figure model or the new three-type model, since the two require genuinely different monitoring approaches. It continues with capturing a clean baseline now, broken out by database, file, and log where that visibility exists, so that the April reclassification and any future ones can be isolated from genuine consumption growth rather than blended into it. It also means understanding the capacity extension option Microsoft makes available once an environment crosses 80 percent utilization: a 45-day window to reduce usage or purchase additional capacity, capped at three extensions in a rolling 365-day period, which is a real safety valve but not one designed to be leaned on indefinitely. And it means deciding, deliberately and in advance rather than reactively during an incident, whether pay-as-you-go billing tied to an Azure subscription is the right overage mechanism for a given environment or whether reallocating from tenant pool capacity is preferable.

For finance and IT leaders who fund these environments, the practical takeaway is that Dataverse storage has moved from a mostly static line item to something closer to a cloud consumption model, with the reporting granularity and billing flexibility that implies, but also the volatility. That is a governance conversation as much as a technical one, and it is worth having before the next reclassification lands rather than after a budget line quietly moves for reasons nobody remembers agreeing to. At Routeget, the engagements that go smoothest are the ones where a client’s storage monitoring gets rebuilt around the new model proactively, rather than the ones where the first real conversation about it happens after an unexpected overage notice.


#Dataverse #DataverseStorage #PowerPlatformLicensing #ITGovernance #DynamicsFinanceOps #CloudCostManagement

What the Power BI PBIR Format Means for Dynamics 365 Reporting Teams

A solution architect reviewing a code diff and a business analytics dashboard on dual monitors in a modern office

A finance reporting team running Power BI over Dynamics 365 Finance and Operations data has a familiar problem: exactly one person can safely have the working capital dashboard open at a time. Everyone else waits, or worse, someone opens the file anyway, makes a change, saves over a colleague’s unsaved edits, and nobody finds out until a client asks why a visual disappeared. That is not a hypothetical. It is how nearly every Power BI report built on top of Dynamics 365 or Dataverse data has been managed since the tool existed, because a .pbix file is a single binary blob. There is no diff, no merge, no pull request, just a file lock enforced by social convention. The Power BI PBIR format changes that mechanic directly, and as of May 2026 it became the default way Power BI Desktop saves new reports, which makes this less a curiosity for early adopters and more a decision every Dynamics 365 reporting practice needs to make on purpose.

PBIR stands for Power BI enhanced report format, and it replaces the older single-file report.json approach (itself an earlier attempt at the same problem, now referred to as PBIR-Legacy) with a folder of small, human-readable JSON files. Microsoft first shipped it as a Desktop developer mode preview several years ago, but the May 2026 update made it the default for both new PBIX files and PBIP projects, meaning teams that never opted into the preview are now creating PBIR reports without necessarily realizing the storage model underneath them has changed.

What the Power BI PBIR Format Actually Changes on Disk

Open a PBIR report’s project folder and you will find a definition directory containing a pages subfolder, a bookmarks subfolder, a report.json for report-level settings, and a version.json that records which format version the report requires. Inside pages, each report page gets its own folder with a page.json and a visuals subfolder, and inside that, every single visual on the page gets its own visual.json file describing its position, formatting, and query. A bookmark becomes its own file too. This sounds like a lot of small files for what used to be one, and it is, but that granularity is the entire point: a change to one chart’s conditional formatting now shows up as a one-file diff instead of an unreadable delta buried inside a compressed binary.

Each of these JSON files declares a public schema URL at the top, and Microsoft has published those schemas on GitHub, which means a report can be opened, validated, and even edited in VS Code with real IntelliSense rather than guesswork. Objects get 20-character generated identifiers by default (something like 90c2e07d8e84e7d5c026), which is ugly to read in a diff but can be renamed to something meaningful through Power BI Desktop, with the caveat that renaming requires restarting Desktop for the change to stick. There is also a lesser-known annotations feature: name-value pairs that Power BI itself ignores completely but that a deployment script can read, which turns out to be useful for marking which page should be the default landing page in a given environment or flagging a visual for environment-specific suppression.

Abstract illustration of branching and merging version control lines connecting to report dashboard blocks

The Git Workflow This Finally Enables

None of the file structure matters much without source control actually using it, and this is where the practical shift happens. A pull request against a PBIR report can now show a reviewer exactly which visual changed and how, the same way a code review shows a diff of a function. Two developers working on different pages of the same report can genuinely work in parallel and merge without one silently overwriting the other, something that was structurally impossible with a monolithic .pbix. Fabric’s own Git integration, which connects a workspace to Azure DevOps or GitHub, extends this further by tracking reports and semantic models at the workspace level and preserving folder structure in the repository, though it is worth being precise here: the file format reaching general availability in Desktop and Fabric’s Git integration support for report and semantic model items reaching full production maturity are two different milestones, and as of this writing the latter is still documented as preview for several connection scenarios, including reports tied to Analysis Services live connections.

A report’s connection to its semantic model is itself stored declaratively, through either a byPath reference that opens the model in full edit mode alongside the report, or a byConnection reference that opens the report in live connect mode with only report-level measures editable. Which one a team chooses affects how much of the semantic model layer gets included in the same Git history as the report, and it is worth deciding deliberately rather than by whatever Power BI Desktop defaulted to on first save.

Why This Matters More for Dynamics 365 Reporting Portfolios

Generic Power BI advice tends to treat this as a nice-to-have for BI teams in general. For a Dynamics 365 F&O or Business Central reporting practice specifically, it addresses a sharper pain point. These environments accumulate large report portfolios fast: financial statement packages, inventory and demand dashboards, project cost tracking, often built by a rotating cast of internal analysts and external consultants over several years. Ownership gets murky, undocumented changes creep in before a board meeting, and when something breaks nobody can say with confidence what changed or when. Power BI Desktop’s version history feature, which also reached general availability in the May 2026 wave alongside the default PBIR change, gives that audit trail natively inside the desktop tool for the first time, which is directly relevant to any organization treating financial report changes as something that needs a change management trail rather than an honor system.

Deployment pipelines benefit in a related way. A report promoted from a development workspace to test and then production can carry annotation-driven configuration differences (a different default page, a different data source binding) without manual reconfiguration at each stage, and the promotion itself becomes something a pipeline log records rather than something a person remembers doing.

Rolling Out PBIR Without Breaking Anything

The rollout mechanics are straightforward but deserve a plan rather than an ad hoc toggle. PBIR is enabled through Power BI Desktop’s preview features under Options, and existing PBIR-Legacy reports convert automatically on the next save, with Desktop creating a backup copy first. That backup detail matters because there is no supported rollback path once a report has converted; the backup is the rollback path, and it lives in a local temp folder with a 30-day retention window, not somewhere a team should rely on long term. The sensible sequence is to pick one lower-stakes report first, ideally something without heavy custom visual dependencies, convert it, get comfortable with the folder structure and the Git workflow in a sandbox repository, and only then extend the practice to the financial statement packages where a mistake actually costs something. Establishing a branching convention (a feature branch per report change, a pull request before merging to the branch a production workspace tracks) before the first real conversion saves a team from learning that lesson under time pressure.

What Still Doesn’t Work Smoothly

A few limitations are worth knowing before committing a whole reporting portfolio to this model. Edits made directly in a code editor do not sync live; the report has to be reopened in Power BI Desktop for those changes to take effect, so treat external JSON edits as a batch operation rather than a live-editing workflow. Two developers can still step on each other if they edit the same page at the same time rather than different pages, since the conflict resolution is granular but not infinite. Service-side limits apply too: a report tops out at 1,000 pages and 1,000 visuals per page, and resource packages are capped at 300 MB, ceilings that rarely matter for a typical operational dashboard but are worth knowing about before designing something unusually large. And a handful of connection types, including push datasets, live connections to on-premises Analysis Services, and older model versions, are excluded from Git integration support entirely for now.

None of that undermines the core shift. Power BI reports built on Dynamics 365 data have functioned for years as single-owner artifacts, reviewed by nobody, versioned nowhere, and handed off through tribal knowledge. PBIR does not fix that automatically, but it removes the technical excuse for not fixing it. The teams that treat this as an application lifecycle management decision, with branching conventions, review checklists, and a deliberate rollout order, will get real governance out of it. The teams that flip the preview toggle and keep working exactly as before will just have smaller binary files. At Routeget, we have been sequencing client Dynamics 365 F&O reporting portfolios through this conversion starting with the highest-change-frequency reports rather than the highest-visibility ones, on the theory that the reports changing every month are where a missing audit trail actually costs someone time.


#PowerBI #PBIR #GitVersionControl #DynamicsFinanceOps #ReportGovernance #MicrosoftFabric

Embedding Copilot Studio Agents in Power Pages: Why Authentication Comes First

A solution architect reviewing a web portal authentication architecture diagram with a chat interface panel on a monitor in a modern office

A solution architect building an external vendor portal in Power Pages gets asked, midway through the project, to add “a chat assistant that can actually answer supplier questions using our own data.” The instinct is to treat this as a UI task: drop in a chat component, point it at Copilot Studio, ship it by Friday. That instinct is the wrong one, and the mistake rarely surfaces on day one. It shows up three weeks later, when the agent works fine for logged-in partners but loops anonymous visitors through a login prompt they were never supposed to see, or when someone in security asks who approved the delegated permissions an agent is now holding on behalf of every anonymous site visitor. The single decision made when adding an agent to a Power Pages site, specifically which authentication model it runs under, quietly determines how it behaves for anonymous users, how much session state it shares with the rest of the portal, and how much rework is waiting the first time that same agent gets published to Teams or Microsoft 365 Copilot alongside the portal. Embedding Copilot Studio agents in Power Pages got considerably more capable in March 2026, and the expanded capability came with a wider set of ways to get the underlying architecture wrong.

A solution architect reviewing a web portal authentication architecture diagram with a chat interface panel on a monitor in a modern office

The Mechanics of Embedding Copilot Studio Agents

Power Pages has offered some form of Copilot-powered chat for a while, but the March 2026 updates changed what that actually means. Microsoft’s own Power Platform blog describes two related capabilities: an Agent API that lets a site’s own custom code build a tailored chat experience against a Copilot Studio agent rather than accepting the default widget, and expanded support for embedding any Copilot Studio agent, using any authentication type the platform supports, directly into a site through the setup workspace. That second piece matters more than it sounds. Previously, a site’s chat experience was tied fairly closely to a narrow generative-answers configuration. Now a maker can either let Power Pages provision a default site agent automatically, or attach a custom agent that was built and tuned independently in Copilot Studio, complete with its own topics, connectors, and orchestration logic.

The setup workflow itself is short. From Power Pages’ setup workspace, under AI Assistance, a maker toggles Site agent on and a generative-answers agent gets created automatically, or selects Add agent to bring in an existing custom one. Either way, the agent then needs web roles assigned before it becomes visible to any site visitor, the same mechanism Power Pages already uses to gate pages and forms. Multiple agents can coexist on one site, each scoped to a different role: a public FAQ agent open to anonymous traffic, say, alongside a case-lookup agent restricted to authenticated partner accounts. Before any of this works, a tenant admin has to enable the “Publish Copilots with AI features” setting in the Power Platform admin center, and the environment’s HTTP connector can’t be blocked, since the agent relies on HTTP nodes to communicate with the site.

The Authentication Fork That Shapes Everything Downstream

Here is where the real architectural decision sits. A default site agent, the one Power Pages provisions automatically, runs on generic OAuth 2 authentication with token pass-through by default. Practically, that means it inherits whatever identity providers the site already has configured, works for anonymous visitors without additional setup, and can tailor its answers based on a visitor’s web role with no extra configuration required. For a straightforward FAQ or knowledge-lookup agent, this is genuinely the easier path, and it is the one most teams will land on without thinking hard about it.

A custom agent added from Copilot Studio, on the other hand, can use any authentication type Copilot Studio itself supports, including direct Microsoft Entra ID authentication rather than the site’s own identity provider. That flexibility exists because some agents need to do more than answer questions from a knowledge source; a topic might need to call back into Dataverse, an external API, or another Microsoft 365 service using a token that carries the visitor’s own delegated permissions. Microsoft’s guidance frames this as a choice between an “Authenticate with Microsoft” option, simple to configure but without token access for topics, and an “Authenticate manually” path that enables token pass-through at the cost of setting up the OAuth registration and scopes correctly.

This is also the point where community reports, appropriately treated as anecdotal rather than confirmed platform behavior, start to matter for planning purposes. A recurring complaint in practitioner discussions is repeated login prompts appearing when a site’s own session and the agent’s authentication flow diverge, often traced back to a token exchange configuration that assumes a session the agent can’t actually see. It is a testable problem, not an unfixable one, but it is the kind of thing that is far cheaper to catch in Copilot Studio’s own testing pane, which now supports validating both the conversation and the authentication flow together, than to discover after a portal has gone live for external users.

Abstract illustration of a glowing padlock merging with a chat bubble and network nodes, representing secure AI agent authentication

Governance Multiplies Across Channels

The authentication decision doesn’t stay contained to Power Pages for long. An agent built once in Copilot Studio is frequently published to more than one surface: the portal, a Teams channel, possibly the Microsoft 365 Copilot app as well. Each channel can carry a different authentication context, which means a topic’s logic that checks for a delegated token, something like a User.AccessToken value, may find it present in one channel and absent in another. A topic written and tested only against the Power Pages experience can behave inconsistently the moment the same agent gets reused somewhere else, and that inconsistency tends to surface as a support ticket rather than a caught bug.

Practically, this argues for treating an embedded agent as a governed asset from the moment it is scoped to more than one channel, not as a Power Pages feature that happens to also work elsewhere. That means a named owner spanning the Copilot Studio author, the Power Pages maker, whoever administers identity for the tenant, and security, rather than assuming the person who built the topic also understands every channel’s authentication quirks. It also means treating the security surface honestly: an agent with broad delegated scopes, reachable from an anonymous-facing portal, is a more attractive target for OAuth consent-phishing style attacks than an internal-only agent would be, and the mitigations worth reviewing (narrower scopes, existing DLP policies, and in higher-sensitivity cases, a backend token-brokering pattern instead of direct client-side pass-through) are worth deciding on before launch, not after an incident review.

What to Confirm Before You Flip the Switch

A few items are worth confirming explicitly rather than assuming. First, decide the authentication model on purpose: the default token pass-through is fine for a lookup-and-answer agent, but anything calling back into Dataverse or another system with delegated permissions needs the manual path, planned for from the start rather than retrofitted. Second, map web roles to agents before enabling anything, since an agent provisioned without a clear role assignment can end up more broadly visible than intended. Third, use Copilot Studio’s own testing capability to validate the authentication flow itself, not just conversation quality, since that is now possible in one place rather than requiring a separate round of manual portal testing. Fourth, budget for consumption: agents provisioned through Power Pages start in a trial period and convert to capacity-based Copilot Studio billing once that period ends, drawing from the same quota pool used by every other Copilot Studio agent in the tenant, so a busy public-facing agent can compete with internal ones for capacity if nobody planned for it.

None of this makes embedding an agent in a Power Pages site a bad idea. It makes it an architecture decision rather than a component you drop onto a page, which is really the same lesson every other Power Pages capability with a security dimension has already taught: the web role model, the table permission model, and now the agent authentication model all reward being decided deliberately in week one. At Routeget, the Power Pages engagements that add agent-powered assistance now start with a short authentication and governance workshop before a single topic gets built, precisely because that conversation is inexpensive early and considerably less so after a portal is already live for external users.


#PowerPages #CopilotStudio #PowerPlatform #AgentAuthentication #PortalGovernance #EnterpriseAI

Dynamics 365 Autonomous Email Resolution: What to Audit Before September 30

Customer service manager reviewing an automated email triage dashboard in a modern operations center

A support mailbox that receives a few thousand emails a month tends to look the same from the outside no matter what’s actually happening inside it: a queue, a set of SLAs, a team quietly triaging password resets, order-status questions, and return requests alongside the handful of cases that genuinely need a human’s judgment. Most customer service leaders already know which categories in that queue are repetitive enough that a well-trained system could handle them end to end. What changes on September 30, 2026, is that Dynamics 365 Customer Service ships autonomous email resolution, a first-party feature built to do exactly that, and the decision about whether to turn it on now belongs on a CIO’s or VP of customer operations’ desk rather than in a future roadmap conversation.

The feature is called autonomous email resolution, and it is delivered through the Case Management Agent that Microsoft has been building out across the last several release waves. Microsoft’s own message center announcement, MC1465523, confirms the general availability date and describes the capability plainly: it analyzes an incoming email, identifies the customer’s intent, checks whether the knowledge and actions needed to resolve it are actually available, and then either sends a resolution, asks a clarifying question, or hands the email off as a fully-contexted case for a person to finish. That last part matters as much as the automation itself. Nothing here is pitched as replacing a support team; it is pitched as removing the portion of the queue that never needed a person’s attention in the first place.

Abstract illustration of an AI agent autonomously processing and resolving an email through a neural network

What autonomous email resolution actually ships on September 30

Reading the feature closely is worth the ten minutes it takes, because the mechanics determine how much control an organization actually retains. Configuration happens in the Copilot Service admin center, under email settings, where an administrator turns on email resolution and then, critically, sets a deployment status separately for each line of business. That per-line-of-business control is the real governance lever here: a line handling password resets or shipping status can be configured for fully autonomous resolution on day one, while a line handling billing disputes or account cancellations can be left in a draft-only mode where the system prepares a response but a representative still reviews and sends it. Nothing forces an all-or-nothing rollout, and organizations that treat this as a binary on/off switch are already making the decision harder than it needs to be.

The dependency chain behind the feature is longer than a single toggle suggests, and each link is worth confirming before a rollout date gets put on a calendar. Email resolution depends on the Customer Intent Agent being configured first, since that agent is what actually identifies what a customer is asking for. It depends on the Case Management Agent’s own guided setup being complete. For the fully autonomous path, where the system sends outbound email without a person in the loop, Microsoft requires a dedicated application user and a shared mailbox set up specifically for that flow, which is a reasonable security boundary but one that needs its own review: whoever owns identity and access management should know that a service account now has standing permission to send customer-facing email on the organization’s behalf.

One constraint is easy to miss and expensive to discover after the fact. Each email resolution configuration supports a single language. An organization running support across English, French, and Spanish mailboxes isn’t looking at one feature toggle; it’s looking at three separate configurations, each requiring its own line-of-business mapping and its own review cycle. That’s not a reason to avoid the feature, but it is a reason to scope the rollout by language and region from the start rather than discovering the limitation mid-deployment.

The billing question worth asking before the license conversation

Here is where the fine print earns its place in this article. Microsoft’s broader Dynamics 365 Customer Service pricing already establishes how most AI agent capabilities get paid for: Professional and Enterprise tier customers consume Copilot Credits, purchased separately from the base per-user license, while the Premium tier bundles in a base allocation of included capacity. That’s the billing model most IT and finance leaders have already built into their Copilot budgeting conversations over the past year.

Autonomous email resolution’s own documentation adds a second billing surface to that picture rather than simply drawing down the same Copilot Credit pool. Microsoft’s configuration guidance lists, as an explicit prerequisite, the Power Platform pay-as-you-go plan, which requires an Azure subscription attached to the environment specifically so the system can charge for agent runs on a consumption basis. In practice, that means a team that has already provisioned Copilot Credits for Case Management Agent’s classification and quality-evaluation capabilities can still be blocked from turning on autonomous email resolution until someone also attaches a billable Azure subscription to the Power Platform environment and enables the pay-as-you-go plan there. Those are two different procurement conversations, often owned by two different teams: one usually sits with the Dynamics 365 or Copilot licensing owner, and the other sits with whoever manages the organization’s Azure subscriptions and cost centers.

This is not a reason for alarm, and it is worth saying plainly that consumption-based billing tied to actual agent runs can be the more sensible model for a capability like this one, since cost then tracks usage rather than seat count. But it is exactly the kind of dependency that gets missed when a rollout gets planned purely as a licensing tier upgrade. The practical fix is straightforward: before scheduling a pilot, confirm that data movement for Copilot and generative AI features is enabled in the Power Platform admin center for the target environment, and confirm separately that an Azure subscription is attached and the pay-as-you-go plan is active, rather than assuming an existing Enterprise or Premium Customer Service license already covers it.

Governance gaps worth planning around, not waiting on

Microsoft’s own documentation, as of this writing, does not publish a specific confidence threshold or scoring mechanism that determines when the system resolves an email autonomously versus escalating it. That is a legitimate gap for governance teams to plan around rather than a reason to delay indefinitely. The practical response is the same one that has worked for every other agentic capability Microsoft has shipped into this product line over the past year: run the feature in its production-ready preview mode against a narrow, well-understood line of business first, watch what it actually resolves versus escalates over a few weeks of real volume, and only then widen the automation level or add a second line of business. Treat the per-line-of-business deployment status setting as the real control surface, since Microsoft has not given administrators a separate dial to tune model confidence directly.

It’s also worth having someone on the compliance or risk side confirm that autonomously sent customer emails, generated from enterprise knowledge and business instructions rather than drafted by a person, fit within existing customer communication policies and any regulatory obligations specific to the industry. A financial services or healthcare organization will likely want a longer review cycle here than a retailer fielding order-status questions, and that difference should shape the rollout timeline more than the September 30 GA date does.

What decision-makers should do this month

The practical sequence for a customer service or IT leader evaluating this feature ahead of GA looks like this: identify one or two lines of business with high email volume and genuinely repetitive, low-risk request types, since these are the best pilot candidates regardless of how quickly the organization intends to expand the feature afterward. Confirm the billing prerequisites on both sides, Copilot Credits and the Power Platform pay-as-you-go plan with an attached Azure subscription, well before the pilot’s target start date, since provisioning an Azure subscription and getting it approved through procurement can take longer than the feature configuration itself. Assign clear ownership of the application user and shared mailbox that the autonomous flow depends on, treating that account with the same access review rigor as any other service identity with outbound communication permissions. And build in a deliberate review checkpoint, perhaps two to four weeks into the pilot, before extending the automation level beyond draft-only for any additional line of business.

Routeget Technologies has walked several clients through exactly this kind of staged agentic rollout across the Dynamics 365 Customer Service and Field Service product lines over the past year, and the pattern holds consistently: the technology tends to work about as well as Microsoft describes it, and the actual project risk sits almost entirely in governance sequencing and billing setup rather than in the AI itself. Getting those two things right before September 30 is a smaller lift than it looks, and it is considerably smaller than untangling them after a line of business has already gone live on autopilot.


#AutonomousEmailResolution #CaseManagementAgent #DynamicsCustomerService #CopilotCredits #CustomerServiceAI #AIGovernance

The Business Central SOAP Retirement Deadline Is Closer Than It Looks

IT director reviewing a systems integration architecture diagram on a monitor in a modern office

The Business Central SOAP Retirement Deadline Is Closer Than It Looks

An IT director doing an annual vendor risk review recently found an integration nobody on her team remembered building. A bank feed connector, installed years earlier by a consultant who has long since moved on, was quietly pulling transaction data into Business Central through a SOAP endpoint pointed at a standard Microsoft page. It had run without incident since before her tenure started. The discovery only mattered because of one line buried in a Microsoft release note: that endpoint, and every other SOAP connection built the same way, stops working the moment Business Central version 29 reaches general availability in the first week of October 2026.

That is the practical shape of the Business Central SOAP retirement. It is not a single dramatic cutoff so much as the final step in a multi-year phase-out that a lot of IT teams filed away as a developer’s problem and never revisited. Microsoft introduced a feature key called “Disable SOAP web services on Microsoft UI pages” in the 2025 release wave 1 update, version 26, and it has been switched on by default ever since, blocking any new attempt to publish a standard Microsoft page as a SOAP endpoint. What made that default setting survivable for older integrations was the fact that an administrator could still go into Feature Management and turn the key back off, keeping the legacy behavior alive. Version 29 removes that feature key entirely. Once it is gone, there is no setting left to flip back on, and any integration still pointed at a Microsoft UI page over SOAP simply stops receiving responses.

The Business Central SOAP Retirement Only Touches Microsoft’s Own Pages

The scope here matters more than the deadline itself, because it is easy to overreact or underreact depending on how the news reaches you. What is actually being removed in version 29 is narrower than “SOAP support in Business Central.” Microsoft’s own justification, stated plainly in its developer documentation, is that a UI page was never designed to function as a stable API contract: a field can move, a control can be renamed, and none of that counts as a breaking change from Microsoft’s perspective, even though it can silently break an integration built directly against that page’s SOAP surface. So the retirement targets exactly that pattern: standard, out-of-the-box Microsoft pages exposed as SOAP web services.

Two other patterns are not affected by this particular change. SOAP endpoints built on codeunits keep working, since a codeunit is intentionally structured as a stable interface rather than a UI surface. SOAP endpoints built on custom, per-tenant extension pages also continue to function, because your organization controls that page’s schema and accepts responsibility for changes to it. If your integration inventory turns out to be built entirely on one of those two patterns, version 29 will not touch it. Many organizations, though, will find that at least one long-running integration, often the oldest one, was built the simple way: pointing directly at a Microsoft page because that was the path of least resistance when someone set it up years ago.

Abstract illustration of a legacy data connector being replaced by a modern API connector

The Stopgap That Isn’t a Real Exemption

Microsoft’s own migration guidance includes an option that looks like an easy out: copy the source of the affected Microsoft page into a per-tenant extension, republish that copy as your own page, and expose the copy as a SOAP endpoint instead. Technically, this works, and it buys time without touching whatever consumes the integration on the other end. It is worth treating as exactly what it is, a stopgap, and not as a long-term architectural decision.

Two things argue against leaning on it permanently. First, you now own and maintain that copied page yourself, including any future logic changes Microsoft makes to the original that you will need to track and replicate by hand, which is precisely the maintenance burden the API-first approach was designed to avoid. Second, this is not the only deprecation moving through the same pipeline. Microsoft has already issued the equivalent warning for exposing Microsoft UI pages as OData endpoints, with removal currently targeted for the 2027 release wave 1 update, version 30. The pattern is consistent: UI-page-based web services of any protocol are being phased out in favor of purpose-built API pages and queries. A team that spends its 2026 budget re-platforming a SOAP integration onto a per-tenant extension, rather than onto a proper API page, is likely to be back doing similar work again in 2027 for the same underlying reason.

What This Means for Your Integration Portfolio

For a CIO or IT director, the practical risk is less about any single connector breaking and more about not knowing how many connectors exist in this pattern in the first place. SOAP-based integrations against Microsoft pages tend to cluster in a few high-value, low-visibility categories: bank statement and payment feeds set up early in an ERP implementation, EDI order intake with a long-standing trading partner, warehouse scanning or shop-floor tools built from an older sample or tutorial, and ISV add-ons purchased years ago from a vendor who may or may not have modernized their own connector since. None of these show up on a typical application inventory unless someone specifically goes looking for the transport protocol underneath them, which is exactly why this kind of deprecation tends to surface as an incident rather than as a planned project.

The financial exposure is concentrated, not diffuse. A broken bank feed means a manual reconciliation process returns overnight, right when finance least wants to discover it. A broken EDI intake means orders stop flowing from a partner who is unlikely to be sympathetic to an internal software upgrade as an excuse. Compare that to, say, a reporting dashboard built the same way, where a short outage is an inconvenience rather than a revenue event. Triage should follow that same logic: not every SOAP endpoint deserves equal urgency, but the ones tied to cash and order flow deserve attention well before the October deadline, not the week of it.

A Practical Sequence Before October

The starting point is visibility, not migration. Business Central logs incoming web service requests, and that telemetry can be pulled to show exactly which endpoints are being called, how often, and by page or codeunit type, before anyone commits engineering time to fixing something that may not even be at risk. From there, the sequence is straightforward in outline even if the execution takes real effort: separate the SOAP calls hitting Microsoft UI pages from those hitting codeunits or per-tenant extensions, since only the first category is on the clock; rank the affected integrations by business impact rather than by ease of fixing them, so a low-effort reporting connector does not quietly jump the queue ahead of a bank feed; and for anything ranked high, start the conversation with whoever owns the other end of the integration; internal developer, systems integrator, or third-party vendor, well before the release actually lands, since REST API pages or OData V4 endpoints for the same data may already exist and simply were never adopted when the integration was first built.

For integrations tied to a purchased ISV app, it is worth a direct question to the vendor rather than an assumption either way: ask specifically whether their connector talks to Business Central over SOAP against a standard page, and if so, what their own migration timeline looks like. A vendor who has not addressed this yet is effectively asking your organization to inherit their technical debt on their schedule, not yours.

Treat This as a Cleanup Project, Not a Fire Drill

The organizations that come out of this in good shape are the ones that treat the Business Central SOAP retirement as the forcing function for an integration inventory they should have had anyway, rather than as an isolated ticket to close before a deadline. We have seen the alternative version of this play out with prior Business Central deprecations: a scramble in the final weeks, a rushed fix that solves the immediate protocol problem without addressing the underlying design, and the same conversation repeating itself at the next deprecation cycle. Version 29 is a good moment to ask the larger question once, properly, rather than answering the narrow one twice.


#BusinessCentral #SOAPRetirement #ERPIntegration #APIModernization #IntegrationGovernance #DigitalTransformation

Configuring Time Entry Duration Controls in Dynamics 365 Project Operations

Project manager reviewing a timesheet approval dashboard showing a calendar grid of time entries

A project accounting lead doing month-end billing reconciliation pulls up a consultant’s timesheet and finds a single day logged at 26 hours. It is almost certainly a typo, someone meant to type 2.6 or fat-fingered an extra digit, but it has already been submitted, approved by a project manager who didn’t look closely, and is sitting in the queue for client invoicing. A few rows down, another resource has logged entries in odd fragments: 7 minutes here, 23 minutes there, none of which line up with the 15-minute billing increments the engagement’s rate card assumes. Neither error is malicious. Both are expensive to catch after the fact, and until this summer, Dynamics 365 Project Operations gave administrators no native way to stop either one at the point of entry.

That gap has started to close. Project Operations now ships two native time entry duration controls that reached general availability within about five weeks of each other in 2026: the ability to configure a maximum daily time entry duration (GA July 24, 2026, tracked in Microsoft 365 message center as MC1425968) and the ability to configure a minimum interval for time entry duration (GA August 31, 2026, MC1443022). Together they give Project Operations something it had previously left entirely to custom validation, whether that meant a Power Automate flow triggered on time entry creation, a plugin registered against the create and update messages, or, more commonly, nothing at all beyond a project manager’s attention during approval.

What the two controls actually do

The maximum daily duration setting lets an administrator define the ceiling on how many minutes a single resource can log across time entries for one calendar day. Per Microsoft’s own release messaging, the configuration is applied from the Parameters page, and it is evaluated every time a time entry is created or modified, not just at submission or approval. That timing detail matters more than it might first appear. It means a resource typing an obviously wrong duration gets an error immediately, in the same session, rather than discovering it later when a project manager rejects the entry or, worse, when it has already cleared approval and shown up on an invoice.

The minimum interval control addresses a different failure mode: durations that are technically valid but operationally useless. Once configured, Project Operations only allows time entries whose duration is a multiple of the value an administrator sets, for example 15 minutes or a full hour. A resource cannot log 22 minutes against a task if the organization has standardized on quarter-hour billing increments; the entry is rejected until it rounds to 15, 30, 45, or 60. Microsoft’s own framing for this feature is squarely about time-tracking policy compliance rather than data hygiene for its own sake, and the distinction is worth sitting with: this is not a cosmetic rounding feature, it is a control meant to make sure recorded time actually maps to how the organization bills or costs labor.

Abstract illustration of a clock face overlaid with a grid representing time entry duration increments

Neither setting appears to expose a granular default in Microsoft’s public documentation beyond the mechanism itself, but field configuration guidance published around the July rollout describes the daily maximum defaulting to a full 24-hour day, meaning 1,440 minutes, until an administrator tightens it. If that reporting holds in your tenant, the practical implication is that this feature does nothing on its own. It has to be explicitly configured to be useful, which is a detail worth confirming in a sandbox before assuming it is protecting anyone.

Rolling out the time entry duration controls without a mess

The temptation with either control is to set the value you actually want on day one: an 8 or 9-hour daily cap matching a standard workday, and a 15-minute increment matching your billing rate card. Resist that instinct for the first rollout cycle. Because validation runs on every create and modify, and because Project Operations time entry has several paths into the system beyond the standard weekly grid, including the Copy Week function, bulk import, and any canvas or model-driven app built against the time entry entity, a tight setting configured without a testing pass tends to surface every non-standard workflow your organization has quietly built up around timesheets.

A safer sequence starts with a maximum daily duration set deliberately loose, something like 16 or 18 hours, purely to catch the genuinely broken entries (the accidental 26-hour day, the decimal-point typo that becomes 240 hours) without touching resources who occasionally work a long day and log it honestly. Watch validation errors for a full billing cycle before tightening toward the actual policy limit. The minimum interval control deserves the same caution, but for a different reason: it will interact directly with any existing Power Automate flows, integrations, or import templates that write time entries with durations your organization never audited closely. An integration pulling hours from a separate scheduling or field service system, for instance, might write entries in whatever granularity that source system uses, and a newly enforced 15-minute increment will start rejecting them the moment it goes live. Map every system of record that writes into project time entries before you set this value, not after.

It is also worth coordinating both settings with how your organization has configured time zone behavior for the time entry grid. Project Operations lets teams choose between time zone aware date handling, where the same entry can display on different calendar dates depending on the viewer’s time zone, and time zone independent handling, which pins the date regardless of viewer location using a dedicated time zone independent date field. For a distributed delivery team spanning multiple time zones, a daily maximum duration check that is evaluated against a date that shifts depending on who is looking at it can produce validation behavior that looks inconsistent to end users, even though the underlying rule hasn’t changed. Confirm which time zone mode is active before assuming daily duration validation will behave the same way for every resource.

What these controls do not solve

Both features validate entries going forward. Neither one appears to retroactively flag or correct time entries that already exist in the system, so a backlog of historical bad data, the kind most organizations discover they have the first time they actually go looking, will not be swept up by turning either setting on. If a data cleanup is part of the motivation for adopting these controls, that remains a separate exercise, likely a Power Platform dataflow or a one-time script against existing records, not something the new parameters retroactively apply.

Equally, neither control replaces approval-stage review. A time entry that respects both the daily maximum and the minimum increment can still be entirely wrong: charged to the wrong project task, misclassified by type, or simply inaccurate about what work actually happened. Duration validation catches a narrow, specific class of error, the kind that shows up as an obviously implausible number or a fractional oddity, and it catches it earlier and more reliably than a human reviewer scanning a timesheet approval queue ever will. It is not a substitute for that review; it removes one category of noise so the review that remains can focus on judgment calls rather than arithmetic.

For organizations running Project Operations at scale, particularly those billing time-and-materials engagements where a single mis-keyed entry can mean a client invoice dispute, these two settings are a genuinely useful, low-effort addition to a governance model that most teams have historically had to build themselves. Getting the rollout sequencing right, testing against every system that writes time entries, and being honest about what the controls do not cover matters more than getting the exact numbers right on day one. Routeget Technologies has walked several Project Operations customers through exactly this kind of parameter rollout, and the pattern holds: the configuration itself takes minutes, and the discovery of what has been quietly writing non-compliant time entries into the system for years takes considerably longer.


#ProjectOperations #TimeEntryValidation #DynamicsFinanceOps #TimesheetGovernance #ERPDataQuality #PSAConfiguration

Power Platform License Enforcement Has a Deadline: February 2027

IT director and finance leader reviewing a software licensing compliance dashboard together in an office

A Power Platform administrator at a mid-size manufacturer got an odd notice in her Microsoft 365 message center in March. It referenced managed environments, a governance feature she associated with premium licensing decisions her CIO had deliberately deferred two budget cycles in a row. She assumed it was routine noise and archived it. Six months later, the same governance feature had been switched on for a dozen production environments without a single approval meeting, because those environments happened to be deployment targets in the organization’s new Power Platform pipelines setup. Nobody had connected the dots between an ALM modernization project and a licensing enforcement clock that started ticking the moment it went live.

That disconnect is becoming common, and it points to a real Power Platform license enforcement deadline that CIOs and IT directors should be treating as a budget line item rather than a footnote in an admin center notification. Microsoft has been quietly retiring the ALM Accelerator for Power Platform, the free, GitHub-based reference implementation many organizations used to bolt source control and deployment automation onto Azure DevOps. In its place, Microsoft is steering everyone toward Pipelines, the native, in-product ALM experience built directly into the Power Platform admin center. The pipelines feature itself is a genuine improvement for most organizations. The licensing mechanics it triggers are the part that deserves scrutiny before anyone signs off on the migration.

Why the ALM Accelerator Is Going Away

The ALM Accelerator was never meant to be permanent. Microsoft built it as a canvas app and Azure DevOps extension pairing, a reference pattern for makers who wanted Git-backed source control and staged deployments without hiring a professional DevOps team. Microsoft’s own documentation now marks it deprecated: no new features, and issues raised against it are no longer reviewed or fixed. The stated successor is Pipelines, described in Microsoft’s guidance as the strategic, in-product experience for maker-initiated application lifecycle management, extensible into Azure DevOps or GitHub when a team needs deeper customization.

For a lot of teams, that is a reasonable trade. Pipelines can be configured in minutes rather than the days or weeks a hand-built Azure DevOps release pipeline typically takes, and it comes with pre-validation, staged approvals, and automatic solution backups out of the box. The tradeoff is that Pipelines requires its non-host target environments, meaning the QA and production environments a solution deploys into, to be managed environments. Development environments are exempt, and the pipeline host itself does not have to be managed, but everything downstream of it does.

IT director and finance leader reviewing a software licensing compliance dashboard together in an office

The Auto-Enablement Nobody Voted On

Here is where the administrator’s ignored notice becomes relevant. Microsoft’s documentation states plainly that starting in February 2026, it began enabling managed environments automatically for any pipeline target environment that was not already configured that way. Tenant admins can opt into a setting under Deployments, Settings in the Power Platform admin center that converts pipeline targets to managed environments proactively, and Microsoft recommends doing so. But the underlying enforcement is not contingent on that opt-in. If a solution is deployed through a pipeline into an unmanaged production environment, Microsoft’s rollout will convert that environment regardless of whether an admin ever flipped the setting.

That matters because managed environments are not a purely technical governance toggle. They carry a licensing dimension that most conversations about ALM modernization skip entirely.

The Licensing Dimension Most ALM Conversations Skip

Managed environments themselves do not cost extra on top of the right license. They come bundled as an entitlement with standalone Power Apps Premium, Power Automate Premium, Copilot Studio, Power Pages, and most Dynamics 365 licenses, along with pay-as-you-go meters for per-app and Copilot Studio consumption. That sounds harmless until you account for how many production apps in a typical enterprise are actually running on seeded or included rights rather than a standalone license: a Power Apps use right bundled into an Office 365 plan, or Power Automate capability included with a Dynamics 365 Pro license and scoped only to that application’s context. Those included rights were never built to satisfy managed environment licensing requirements on their own, and Microsoft’s own FAQ language on the topic notes that Power Apps or Power Automate capability tied to a Dynamics 365 Pro license is meant to be used only within that licensed application, not as a general-purpose citizen development platform.

Managed environments carry an autoclaim policy that automatically assigns the correct license to a user who accesses an app there, provided the tenant has license capacity to draw from. Autoclaim solves the paperwork problem of manually assigning licenses one user at a time. It does not solve the budget problem of simply not owning enough qualifying licenses to autoclaim against, and it does nothing for a user whose only access to Power Apps or Power Automate comes through a seeded right that was never designed to extend into a managed, governed production environment.

Abstract illustration of a countdown clock merging with a network of cloud environment nodes, some locked and some unlocked

The Power Platform License Enforcement Timeline You Are Already Inside

This is not a distant, hypothetical deadline. Microsoft’s published timeline shows administrative notifications through the Microsoft 365 message center and Power Platform admin center beginning in March 2026. In-app notifications aimed directly at end users without an appropriate license started in June 2026, following a staged escalation: an informational message on day one, a warning after seven days, and an error state after fifteen, each urging the user to request a license from an admin. The hard stop lands in February 2027: users who still lack an appropriate license at that point are blocked from opening the app entirely, shown a standard message telling them they need a Power Apps license to use it. Apps are not deleted and access resumes automatically once a qualifying license is detected, but for that window, whatever workflow depended on that app simply stops working for that user.

Given today’s date, that means the notification phase is already well underway inside most tenants that run pipelines against production environments, and the enforcement date is now closer than most annual license renewal cycles.

What This Means for the Business Case

None of this is a reason to avoid Pipelines or to keep patching together an already-deprecated ALM Accelerator deployment. The practical response is to treat the license audit as part of the ALM modernization project plan rather than as an afterthought that surfaces after go-live. That means pulling a current list of every user who accesses production apps sitting in, or scheduled to sit in, a pipeline-managed environment, and checking each one against a standalone qualifying license rather than assuming a Microsoft 365 or Dynamics 365 seat covers it. It means asking whether apps currently running on included, scoped rights actually need to move to standalone Premium licensing, get rearchitected to stay within their original licensed application’s context, or get retired if nobody can justify the cost. And it means giving finance and procurement enough lead time to true up license counts well before February 2027, rather than discovering the gap when a plant floor supervisor gets locked out of a production app and escalates it as an outage.

Organizations that have gone through this kind of ALM transition tend to find the technical migration to Pipelines is the easy part. The harder, more valuable work is the license and governance audit that should have accompanied it from the start, which is usually where firms like Routeget Technologies get pulled into these engagements: less to configure a pipeline, more to make sure the environments behind it do not quietly turn into a compliance problem eleven months later.


#PowerPlatformPipelines #ManagedEnvironments #ALMGovernance #PowerPlatformLicensing #LicenseComplianceAudit #EnterpriseGovernance

The AI Builder Credits Transition Has a Deadline: November 1, 2026

Finance and IT leaders reviewing Power Platform licensing budget charts on a laptop in an office setting

A Power Platform administrator at a mid-market distributor recently walked into her CFO’s office with a number nobody had budgeted for. Her company’s invoice-processing flow, built on AI Builder’s document processing models three years ago, had been running on credits bundled quietly into a Power Automate Premium renewal. That renewal comes up again in October. She had just learned that whatever gets signed this fall will be the last one to include those free credits at all, and that the resulting seeded credits and add-on option would disappear entirely for anyone who renews after November 1, 2026. Nobody in finance had flagged it as a line item, because for three years it had never been one.

That scenario is becoming common across organizations that adopted AI Builder early, when its credits shipped as a quiet inclusion in Power Apps, Power Automate, and Dynamics 365 licenses rather than a metered, purchased capacity. The AI Builder credits transition Microsoft is now enforcing retires that model outright, and the cutoff sits close enough on the calendar that IT Directors and finance leaders currently mid-negotiation on a Power Platform renewal need to understand it before they sign, not after.

What the AI Builder credits transition actually changes

Abstract illustration of digital credit tokens flowing between two separate licensing systems

AI Builder, the low-code AI layer inside Power Apps and Power Automate that handles document processing, form extraction, sentiment analysis, and prediction models, has historically been funded two ways: seeded credits bundled into premium licenses at no extra cost, and AI Builder capacity add-ons purchased separately when an organization’s usage outgrew the bundled amount. Microsoft’s documentation lists specific seeded allotments: Power Apps Premium includes 500 AI Builder credits, Power Apps per-app licenses include 250, Power Automate Premium and its RPA add-ons include 5,000 each, and Dynamics 365 Finance and Operations includes 20,000. A standalone AI Builder capacity add-on carries 1,000,000 credits.

Starting November 1, 2025, Microsoft closed new-customer sales of AI Builder capacity add-ons and shifted AI Builder features onto a dual-currency consumption model: an environment draws down its AI Builder credits first, and if those run out, the system automatically falls back to Copilot Credits before blocking the operation. Existing add-on customers could still renew and purchase through that window. November 1, 2026 is the harder cutoff. On that date, existing AI Builder capacity add-ons reach end of life: customers with an active add-on keep using the credits tied to it, but can no longer renew it or buy a new one. Separately, any Power Platform or Dynamics 365 license purchased or renewed on or after that date stops receiving seeded AI Builder credits altogether. If your renewal lands in September or October, you’re likely getting the last cycle that includes them at no incremental cost. If it lands in November or later, that inclusion is gone for the new term.

Microsoft has been explicit that it will honor entitlements already under contract. Licenses and add-ons purchased before the cutoff keep their credits for the remainder of that specific contract term, whatever length that is. What changes is the next renewal, not the current one already in force. That distinction matters enormously for budget planning, because it means the financial exposure isn’t immediate for most organizations. It arrives at whatever renewal date happens to fall after November 1, and for some finance teams that’s uncomfortably close.

Why this is a budgeting problem, not a technical one

The mechanically important detail, and the one most likely to catch a finance team off guard, is that there is no automatic conversion between the two credit systems. Microsoft’s own documentation states plainly that AI Builder credits and Copilot Credits are separate currencies with separate consumption rates per action, and unused AI Builder credits don’t roll over or translate into an equivalent number of Copilot Credits when the seeded allotment disappears. An organization that has been running document processing workloads for years on a bundled 20,000-credit Dynamics 365 F&O allotment, or a 5,000-credit Power Automate Premium allotment, needs to separately estimate what the equivalent workload costs once it draws exclusively on purchased Copilot Credits, because the published rate cards for the two currencies aren’t set up to produce the same effective cost per document or per prediction. Assuming last year’s consumption simply carries forward at the same dollar cost is the exact assumption this transition breaks.

This is where the business risk actually lives. AI Builder adoption inside Dynamics 365 F&O and Business Central environments tends to concentrate in exactly the processes finance departments care most about protecting: accounts payable invoice capture, receipt and expense processing, contract data extraction, vendor document classification. These are high-volume, repetitive workloads that were attractive to automate specifically because the seeded credits made the marginal cost of processing another document effectively zero. Once that seeded allotment is gone, the marginal cost stops being zero, and depending on volume, it can become a meaningful new operating expense that nobody modeled into the automation’s original ROI case.

What CIOs, CFOs, and Power Platform administrators should do before their next renewal

The first step is straightforward but frequently skipped: pull actual AI Builder consumption data from the Power Platform Admin Center, under Licensing and Capacity add-ons, before the renewal conversation starts rather than during it. Monthly consumption resets and doesn’t accumulate, so a single month’s snapshot understates volume during seasonal peaks like month-end close or year-end 1099 processing. Look at a full quarter, not a spot check.

The second step is checking renewal timing against the cutoff with more precision than “sometime this year.” A Power Automate Premium license renewing October 15 keeps its seeded credits for that full new term even though the term extends past November 1, since Microsoft’s honoring rule is tied to the contract’s start date, not to a mid-term calendar boundary. A license renewing November 15 does not get that benefit. For organizations with renewal dates close to the line, it’s worth confirming the exact contractual start date with a Microsoft partner or account team rather than assuming based on the calendar month alone.

Third, for teams that expect to keep growing AI Builder-dependent automation rather than shrinking it, purchasing or renewing an AI Builder capacity add-on before November 1, 2026 locks in access to that add-on’s credit pool and its associated rate for as long as the add-on contract runs, even though new add-on purchases stop being available afterward. That’s a genuine one-time window, not a recurring option, and it’s worth evaluating now rather than assuming it will still be available closer to the deadline.

Finally, this is a reasonable moment to model Copilot Credit costs for AI Builder workloads specifically, rather than treating Copilot Credits as an abstract budget line shared across every AI feature in the tenant. Document processing, form extraction, and prediction actions each draw against Copilot Credits at their own published rate once AI Builder credits are exhausted, and an organization running several automated document workflows across F&O, Business Central, and Power Automate should size that consumption separately from whatever Copilot Studio agent or Copilot chat usage is already drawing from the same pool. Treating them as one undifferentiated bucket is how a finance team ends up with a Copilot Credit shortfall it didn’t see coming from an entirely different application.

None of this requires panic, and it doesn’t require ripping out working automation. It requires treating a licensing calendar date the way a solution architect would treat any other deprecation notice: as a planning input with a hard date attached, not a vague future concern. At Routeget Technologies, the licensing transitions we’ve helped clients navigate tend to follow the same pattern: the technical migration is manageable, but the budget surprise is what actually causes friction with finance. Getting ahead of the renewal date, and getting real consumption numbers in front of the people who sign the contract, is what turns this from a surprise into a line item.


#DynamicsAIBuilder #CopilotCredits #PowerPlatformLicensing #ERPBudgetPlanning #EnterpriseAI #FinanceAutomation

Power Apps Component Libraries vs. Code Components: Choosing a Reuse Strategy That Holds Up

Solution architect reviewing multiple Power Apps interface mockups on a monitor, representing component reuse across canvas apps

A Power Apps center of excellence at a mid-size manufacturer recently discovered that its “shared” approval banner control existed in eleven slightly different versions across eleven canvas apps. Every app maker had pulled the component in at some point, tweaked a color or a label to fit their screen, and moved on. When a compliance requirement forced a wording change across all of them, nobody could say with confidence which apps were actually running the current version without opening each one and checking manually. The team had built a Power Apps component library specifically to prevent this. It didn’t, because nobody on the team understood how a component library actually propagates changes.

That gap between what makers assume Power Apps component libraries do and what they actually do is one of the more expensive misunderstandings in a growing Power Apps estate, and it only gets worse as the number of apps and makers increases. Solution architects planning a reuse strategy have two real options inside the platform: canvas component libraries, the no-code mechanism most makers reach for first, and code components built on the Power Apps component framework (PCF), which have been usable inside canvas apps since general availability in June 2021 but remain underused outside professional development teams. Picking between them, or more realistically deciding where each one belongs, requires understanding a few mechanics that the tooling doesn’t make obvious at first glance.

Power Apps component libraries copy, they don’t link

The detail that trips up most teams is this: when a canvas app imports a component from a library, Power Apps copies that component’s full definition into the app itself. The app becomes, in Microsoft’s own terminology, self-contained with respect to that component. There is no live reference back to the library sitting in Dataverse. This is a deliberate design choice that lets an app keep functioning even if it’s exported to an environment where the source library doesn’t exist, but it means updates are never automatic.

When a library owner publishes a change, consuming apps get a notification the next time a maker opens that app for editing, or a maker can proactively check for updates from the Insert pane. Either way, someone has to look at the diff, decide to accept it, and republish the app. Skip that step across even a handful of apps and you end up exactly where the manufacturer above did: a library that is current, and a fleet of apps that quietly are not.

Abstract illustration of glowing modular panel blocks assembling together, representing reusable Power Apps components

A few structural details make this worse if they’re not planned for early. Microsoft’s own guidance caps component libraries at roughly twenty components for performance reasons, which means a library that grows organically without a naming or grouping convention eventually has to be split, and that split itself becomes a migration project. If a maker edits a library-sourced component directly inside an app instead of going back to the library, that action silently breaks the link and creates a local, permanently divergent copy, though the dependency reference stays visible in the Insert pane, which makes it look connected when it isn’t. And library components carry a managed property called “Allow customizations.” When it’s turned off in a target environment, nobody downstream can adjust the component locally at all, which is often the right call for a governed control but needs to be a conscious decision, not a default nobody reviewed.

Where solution export makes this a governance problem, not just a hygiene one

Application lifecycle management adds another layer that’s easy to miss if a team is exporting solutions on a schedule rather than reviewing them individually. Solution export always packages the latest published version of the component library, regardless of which version any given consuming app has actually accepted. That means the correct sequence is to update every dependent app to the current component version first, then export. Do it backward, and you can ship a solution where the library and the apps inside it are on different versions of the same control, which typically surfaces as a subtle visual or behavioral inconsistency rather than an outright error.

There’s also a one-time synchronization quirk worth knowing before a first deployment: when an app and its library move to a target environment together, Power Apps treats them as synchronized at that moment and won’t prompt for updates again until the library is reimported with a newer version. Teams that assume update notifications will keep working the same way in production as they did in the maker’s development environment are often surprised when that stops happening. And because Dataverse tracks the dependency relationship, a library can’t be deleted while any app still references it, and a missing library in a solution import produces a hard failure rather than a warning, which is a reasonable safety net but one that catches teams off guard when they’ve assumed a component library is just another kind of shared file.

What code components are actually for

Power Apps component framework code components sit at a different point on the build-versus-govern spectrum. A system administrator has to explicitly enable the Power Apps component framework for canvas apps at the environment level before any maker can use one, which is itself a useful governance checkpoint that a canvas component library doesn’t have. Building one requires the Power Platform CLI and TypeScript rather than the canvas designer, and the finished component gets packaged into a Dataverse solution and imported like any other managed asset, which puts it squarely inside standard ALM pipelines instead of the copy-and-notify model described above.

The tradeoff is real, not cosmetic. Code components running inside canvas apps can’t call the Dataverse Web API directly, and they can’t implement custom authentication; both of those have to be handled through connectors instead, which rules out certain integration patterns that would be straightforward in a model-driven app. Microsoft’s documentation is also direct about the security posture: because a code component is executable code with access to the same context and tokens as the app around it, the platform surfaces an explicit warning when someone imports one, and the stated guidance is to treat unfamiliar components the way you’d treat any third-party dependency, which is to say, review it before it goes anywhere near a production environment.

A workable split, not a single winner

None of this argues for abandoning component libraries in favor of code components, or the reverse. The two mechanisms are suited to different kinds of reuse, and the architects who get the most value out of Power Apps treat the choice as a deliberate design decision rather than whichever option the maker who built the first version happened to know.

Component libraries are the right tool for UI patterns that app teams themselves need to iterate on: a standard header, a status badge, a form validation pattern that will keep evolving as business rules change. The update-and-review workflow is a feature here, not a bug, because it gives each app team a checkpoint before absorbing a change, provided someone actually owns checking for updates on a schedule rather than leaving it to chance. Code components are the better fit for controls that need to be built once, security-reviewed once, and then distributed as a locked, vetted building block: a specialized data visualization, a control that needs rendering performance a canvas formula can’t deliver, or anything a center of excellence wants to hand out without giving every consuming team edit access to the internals.

The practical starting point for a team building either strategy is small: split libraries along functional lines before they approach the twenty-component ceiling, require a version note on every publish so consumers can judge a change before accepting it, and add a step to the solution export checklist that confirms every dependent app has actually synced to the latest component version. For code components, route imports through whatever center of excellence review process already governs custom connectors, since the risk profile is similar. None of this is complicated once it’s written down, which is precisely why it’s worth writing down before the first inconsistent approval banner shows up in an audit, rather than after. Routeget Technologies has helped several clients untangle exactly this kind of fragmented reuse setup during broader Power Platform governance engagements, and the fix is almost always process, not a missing feature.


#PowerApps #ComponentLibraries #PowerAppsComponentFramework #ALMGovernance #LowCodeGovernance #CanvasAppArchitecture

Dynamics 365 Sales Home Lead Research Reaches GA. Read the License Fine Print First.

Sales operations manager reviewing an AI-prioritized lead list on a dashboard screen in a modern office

A sales operations director at a mid-market manufacturer spent part of August walking her CRO through the 2026 release wave 1 notes for Dynamics 365 Sales, and one line stood out: Sales Home lead research and next best actions were shipping this wave, landing directly on the screen every rep already opens first thing in the morning. It read like a free upgrade, the kind of quiet interface improvement Microsoft ships every wave without anyone needing to ask for it. Then she checked the prerequisites. The feature does not turn on by itself. It requires the Sales Qualification Agent, or its lead research capability, to be provisioned first, and that agent draws from the same Copilot Credit pool her finance team had already earmarked for a completely different AI rollout in customer service. What looked like a UI refresh was actually a new consumption-based line item, and nobody in the budget conversation had accounted for it.

That gap between how a feature reads in the release notes and how it actually gets paid for is becoming a recurring theme in the Dynamics 365 Sales roadmap, and it is worth understanding in detail before your own team flips the switch.

Sales operations manager reviewing an AI-prioritized lead list on a dashboard screen in a modern office

What Sales Home Lead Research Actually Does

The feature itself, officially titled “Get lead research and next best actions in Sales Home,” reached general availability this month after entering public preview in June. It puts a prioritized, AI-scored list of leads directly on the home screen sellers already use, ranked by urgency, fit, and engagement signals rather than by creation date or a manually assigned score. For each lead, the panel surfaces a short research summary, the reasoning behind why the system considers it worth pursuing now, and a recommended next action, whether that is a follow-up call, a qualification step, or simply unblocking an agent that is waiting on a decision. Sellers can act on the recommendation without leaving Sales Home, and the system tracks whether the action was taken so high-value leads stop quietly stalling in someone’s queue.

On paper, this solves a real and common problem. Most sales teams do not lack leads; they lack a reliable way to decide which ten of the two hundred leads sitting in a queue actually deserve a call this morning. Manual lead scoring models built on static rules tend to go stale within a quarter, and reps develop their own private heuristics that rarely match what marketing or revenue operations intended. A model that explains its reasoning, rather than just spitting out a number, addresses the trust problem that has quietly limited adoption of every previous generation of predictive lead scoring in this platform.

The Licensing Mechanic Buried in the Prerequisites

Here is where the release notes get less generous with detail than a budget owner would like. The Sales Home panel is not a standalone capability; it is a surface built on top of the Sales Qualification Agent, which does the actual research and reasoning work in the background. That agent is available with Dynamics 365 Sales Professional, Enterprise, or Premium licensing, but it consumes Copilot Credits with every research pass, every drafted outreach email, and every autonomous follow-up it sends. Premium licensing includes an allotment of 1,000 credits per user per month; everything past that draws from a purchased credit pool that is shared across every Copilot-metered feature in the tenant, not ring-fenced for Sales Home alone.

Abstract visualization of a metered digital consumption gauge representing Copilot Credit usage

That last detail matters more than it sounds. Organizations running Dynamics 365 Sales alongside Customer Service or Field Service are increasingly stacking multiple agentic features onto the same finite credit budget: a qualification agent working inbound leads, a service agent summarizing cases, perhaps a Copilot Studio agent doing something entirely unrelated to sales. None of these consumption patterns are visible to a sales operations leader evaluating a single feature in isolation, which is exactly the position our manufacturing client found herself in. The fix is not complicated, but it does require a step most teams skip: pull actual Copilot Credit consumption reports from the admin center before approving a new agent, rather than assuming existing licensing already covers it.

A Cautionary Parallel Already Sitting in the Same Interface

Sales Home is not new territory for features that look simpler in a release note than they turn out to be in production, and the platform’s own history with Sequences is instructive. Sequences, the guided step-by-step workflow tool for structuring outbound cadences, shipped years ago with obvious appeal and has been quietly constrained ever since by details that never made it into the initial pitch. It ties automated email steps to a seller’s personal mailbox, so organizations relying on shared or group mailboxes for outbound outreach have had to build custom workarounds. Enterprise-tier licensing caps sequence assignments at 1,500 records a month, a ceiling that arrives faster than most sales operations teams expect once a cadence scales past a pilot team, and lifting it means moving to Premium. Even the interface has friction: when Sequences’ “Next Up” panel and the standard Timeline component both appear on the same record, reps report genuine confusion about which one is actually telling them what to do next.

None of this means Sequences was a bad investment, and it does not mean the new lead research panel will repeat every one of these specific problems. It means that features surfaced in Sales Home tend to carry structural constraints, whether licensing caps, mailbox dependencies, or credit consumption, that only become visible once a team is past the pilot and into real volume. A decision-maker evaluating the new panel should treat that pattern as a reason to pilot deliberately rather than roll out broadly on day one.

What the Early Evidence Actually Shows

Microsoft has published its own benchmark for the underlying Sales Qualification Agent, introduced in December 2025 as the Microsoft Sales Bench, which compared the agent against a general-purpose model across identical synthetic lead datasets judged by both human reviewers and an LLM evaluator. The agent scored roughly six percent higher on research quality, twenty percent better on outreach personalization and timeliness, and sixteen percent higher on multi-turn engagement handling. Those numbers are worth taking seriously as a signal that Microsoft has purpose-built this agent for the sales qualification task specifically, rather than wrapping a generic model around CRM data. They should also be read for what they are: an internally run comparison on synthetic data, not an independent third-party audit, and a reasonable board-level question is whether your own historical lead data, industry, and deal complexity resemble the benchmark’s assumptions closely enough for the numbers to transfer.

A more grounded data point comes from an early adopter, Sandvik Coromant, whose pilot reportedly saved roughly 120 hours and nineteen thousand dollars in labor cost over three weeks, with a forecasted five percent revenue lift once rolled out fully. That is a genuinely useful reference point, and it is also a single case study from one organization’s specific lead volume and sales motion. Treat it as evidence the mechanism can work, not as a guaranteed return for every deployment.

Questions Worth Answering Before Enabling It

Before turning this on for a full sales organization, a few questions deserve real answers rather than assumptions. First, what is your current Copilot Credit consumption across every agent already running in the tenant, and how much headroom does that leave for a new, continuously-running qualification agent working every inbound lead? Second, is your lead data clean enough for a fit-and-engagement model to produce useful rankings, or will the agent simply be scoring noise, since garbage lead records produce garbage prioritization regardless of how good the underlying model is? Third, has your team learned the operational lessons Sequences already taught the organization about mailbox dependencies and licensing tiers, and does the rollout plan account for the fact that Premium licensing changes both the credit allotment and the feature ceiling?

None of these questions should stop a team from adopting a genuinely capable piece of AI-assisted sales tooling. They should shape how the rollout is sequenced: a single team piloting for a full quarter with credit consumption tracked explicitly, rather than a tenant-wide switch flip driven by excitement over a release note. Routeget Technologies has walked several clients through exactly this kind of staged Copilot-agent adoption inside Dynamics 365 Sales, and the pattern holds consistently: the technology performs well when the budgeting and governance work happens first, and creates friction almost every time it happens after the fact.

The lead research panel in Sales Home is a real improvement to a genuine problem, giving sellers a defensible answer to which lead to call next instead of a gut feeling. Just make sure procurement and revenue operations are reading the same release note your sales team is excited about, because the license question and the feature announcement did not ship in the same paragraph.


#SalesHomeAI #Dynamics365Sales #CopilotCredits #SalesQualificationAgent #RevenueOperations #LeadPrioritization