Maximizing Your Power Platform Solution’s Reach: Essential Performance Considerations for Optimal Efficiency

Hi Folks,

This blog post is all about performance considerations for your Power Platform CE Projects and how you can plan to optimize application performance for your Power Apps. So I just want to take you through them…

Are you tired of creating solutions for longer durations and while at the end of the project or during UAT you end up facing performance issues for the solutions you have developed, one of the most important non-functional requirements for a project’s success is Performance. Satisfying performance requirements for your users can be a challenge. Poor performance may cause failures in user adoption of the system and lead to project failure, so you might need to be careful for every decision you take while you design your solutions in the below stages.

Let’s talk about them one by one..

1. Network Latency and bandwidth

A main cause of poor performance of Dynamics 365 apps is the latency of the network over which the clients connect to the organization. 

  • Bandwidth is the width or capacity of a specific communications channel.
  • Latency is the time required for a signal to travel from one point on a network to another and is a fixed cost between two points. And usually many of these “signals” travel for a single request.

Lower latencies (measured in milliseconds) generally provide better levels of performance. Even if the latency of a network connection is low, bandwidth can become a performance degradation factor if there are many resources sharing the network connection, for example, to download large files or send and receive email.

Dynamics 365 apps are designed to work best over networks that have the following elements: 

  • Bandwidth greater than 50 KBps (400 kbps)
  • Latency under 150 ms

These values are recommendations and don’t guarantee satisfactory performance. The recommended values are based on systems using out-of-the box forms that aren’t customized.

If you significantly customize the out-of-box forms, it is recommend that you test the form response to understand bandwidth needs.   

You can use the diagnostics tool to determine the latency and bandwidth:

  1. On your computer or device, start a web browser, and sign in to an organization.
  2. Enter the following URL, https://myorg.crm.dynamics.com/tools/diagnostics/diag.aspx, where crm.dynamics.com is the URL of your organization.
  3. Click Run.

Also, to mitigate higher natural latency for global rollouts, customers should leverage Dynamics 365 Apps successfully by having smart design for their applications. 

2.Smart Design for your application

Form design 

  • Keep the number of fields to a minimum. The more fields you have in a form, the more data that needs to be transferred over the internet or intranet to view each record. Think about the interaction the user will have with the form and the amount of data that must be displayed within it.
  • Avoid including unnecessary JavaScript web resource libraries. The more scripts you add to the form, the more time it will take to download them. Usually, scripts are cached in your browser after they are loaded the first time, but the performance the first time a form is viewed often creates a significant impression.
  • Avoid loading all scripts in the Onload event. If you have code that only supports OnChange events for fields or the OnSave event, make sure to set the script library with the event handler for those events instead of the OnLoad event. This way loading those libraries can be deferred and increase performance when the form loads.
  • Use tab events to defer loading web resources. Any code that is required to support web resources or IFRAMEs within collapsed tabs can use event handlers for the TabStateChange event and reduce code that might otherwise have to occur in the OnLoad event.
  • Set default visibility options. Avoid using form scripts in the OnLoad event that hide form elements. Instead set the default visibility options for form elements that might be hidden to not be visible by default when the form loads. Then, use scripts in the OnLoad event to show those form elements you want to display. If the form elements are never made visible, they should be removed from the form rather than hidden.
  • Watch out for synchronous web requests as they can cause severe performance issues. Consider moving to asynchronous for some of these web requests. Also, choose WebApi over of creating Xml HTTP Requests (XHR) on your own. 
  • Avoid opening a new tab or window and do open the window in the main form dialog. 
  • For Command Bar, keep the number of controls to a minimum. Within the command bar or the ribbon for the form, evaluate what controls are necessary and hide any that you don’t need. Every control that is displayed increases resources that need to be downloaded to the browser. Use asynchronous network requests in Custom Rules When using custom rules that make network requests in Unified Interface, use asynchronous rule evaluation.

Learn more Design forms for performance in model-driven apps – Power Apps | Microsoft Learn

Latest version of SDK and APIs 

The latest version of SDK, Form API and WebAPI endpoints should be used to support latest product features, roadmap alignment and security. 

APIs calls and custom FetchXML call velocity 

Only the columns required for information or action should be included in API calls: 

  • Retrieving all columns (*) creates significant overhead on the database engine when distributed across significant user load. Optimization of call velocity is key to avoid “chatty” forms that unnecessarily make repeated calls for the same information in a single interaction.
  • You should avoid retrieving all columns in a query result because of the impact on a subsequent update of records. In an update, this will set all field values, even if they are unchanged, and often triggers cascaded updates to child records. Leverage the most efficient connection mechanism (WebAPI vs SDK) and reference this doc site for guidance on the appropriate approach.

Consider reviewing periodically the Best practices and guidance when coding for Microsoft Dataverse – Power Apps | Microsoft Learn and ColumnSet.AllColumns Property (Microsoft.Xrm.Sdk.Query) | Microsoft Learn.

Error handling across all code-based events 

You should continue to use the ITracingService.Trace to write to the Plug-in Trace Log table when needed. If your plug-in code uses the ILogger interface and the organization does not have Application Insights integration enabled, nothing will be written. So, it is important to continue to use the ITracingService Trace method in your plug-ins. Plug-in trace logs continue to be an important way to capture data while developing and debugging plug-ins, but they were never intended to provide telemetry data.  

For organizations using Application Insights, you should use ILogger because it will allow for telemetry about what happens within a plug-in to be integrated with the larger scope of data captured with the Application Insights integration. The Application Insights integration will tell you when a plug-in executes, how long it takes to run and whether it makes any external http requests. Learn more about tracing in plugins Logging and tracing (Microsoft Dataverse) – Power Apps | Microsoft Learn.   

Use Solution Checker to analyze solution components 

Best practice is to run Solution Checker for all application code and include it as mandatory step while you design solutions or check when you complete developing your custom logic.

Quick Find 

For an optimal search experience for your users consider the next:

  • All columns you expect to return results in a quick find search need to be included in the view or your results will not load as expected.
  • It is recommended to not use option sets in quick find columns. Try using the view filtering for these. 
  • Minimize the number of fields used and avoid using composite fields as searchable columns. E.g., use first and last name as searchable vs full name.
  • Avoid using multiple lines of text fields as search or find columns.
  • Evaluate Dataverse search vs using leading wildcard search

3. Training

This step should be done during user training or during UAT. To ensure optimal performance of Dynamics 365, ensure that users are properly leveraging browser caching. Without caching, users can experience cold loads which have lower performance than partially (or fully) warm loads.

 Make sure to train users to: 

  • Use application inline refresh over browser refresh (should not use F5)
  • Use application inline back button instead browser’s back button.
  • Avoid InPrivate/Incognito modes in browser which causes cold loads.
  • Make users aware that running applications which consumes lot of bandwidth (like video streaming) may affect performance.
  • Do not install browser extensions unless they are necessary (this might be also blocked via policy)
  • Do use ‘Record Set’ to navigate records quickly without switching from form back to the list. 

4. Testing

For business processes where performance is critical or processes having complex customizations with very high volumes, it is strongly recommended to plan for performance testing. Consider reviewing the below technical talk series describing important performance considerations, as well as sharing practical examples of how to set up and execute performance testing, and analyze and mitigate performance issues. Reference: Performance Testing in Microsoft Dynamics 365 TechTalk Series – Microsoft Dynamics Blog

5. Monitoring

You should define a monitoring strategy and might consider using any of the below tools based on your convenience.

  1. Monitor Dynamic 365 connectivity from remote locations continuously using network monitoring tools like Azure Network Performance Monitor or 3rd party tools. These tools help identify any network related problems proactively and drastically reduce troubleshooting time of any potential issue. 
  2. Application Insights, a feature of Azure Monitor, is widely used within the enterprise landscape for monitoring and diagnostics. Data that has already been collected from a specific tenant or environment is pushed to your own Application Insights environment. The data is stored in Azure Monitor logs by Application Insights, and visualized in Performance and Failures panels under Investigate on the left pane. The data is exported to your Application Insights environment in the standard schema defined by Application Insights. The support, developer, and admin personas can use this feature to triage and resolve Telemetry events for Microsoft Dataverse – Power Platform | Microsoft Learn
  3. Dataverse and PowerApps analytics in the Power Platform Admin Centre. Through the Plug-in dashboard in the Power Platform Admin Center you can view metrics such as average execution time, failures, most active plug-ins, and more.
  4. Dynamics 365 apps include a basic diagnostic tool that analyzes the client-to-organization connectivity and produces a report.
  5. Monitor is a tool that offers makers the ability to view a stream of events from a user’s session to diagnose and troubleshoot problems. Works both for model driven apps and canvas apps. 

I hope this blog post had helped you learn or know something new…thank you for reading…

Cheers,

PMDY

Dataverse or SQL Server? And Where Does PostgreSQL Fit…for Power Apps Implementation?

Hi Folks,

Hope you’re all doing great and staying safe. This week, let’s dive into a question almost every architect, developer, and Power Platform enthusiast eventually faces when choosing a backend for the implementation—but rarely gets a clear answer to:

“Should I use Dataverse, SQL Server, or PostgreSQL for my next Power Apps solution…?”

With so many platforms claiming speed, scalability, flexibility, and low‑code magic, choosing the right one can feel like navigating a maze. But don’t worry—I’ve broken it all down into a simple, structured guide that can help you guide your implementation choice.

Whether you’re building Power Apps, designing enterprise systems, or architecting cloud‑native solutions, this comparison will help you. You will understand what each platform really offers. You will see how they differ. And—most importantly—which one fits your scenario best.

Let’s jump in and make your next data decision a confident one.

“Firstly, why think of PostgreSQL, in a Microsoft ecosystem

While Power Platform implementations rarely use PostgreSQL directly, it remains one of the most widely adopted enterprise databases. Including it in this comparison helps architects understand how Microsoft’s data platforms stack up against a major industry standard.”

High‑Level Summary

Dataverse is a managed, low‑code data platform built for the Microsoft Power Platform. SQL Server is a commercial, enterprise-grade relational database tightly integrated with the Microsoft ecosystem. PostgreSQL is an open‑source, highly extensible relational database known for standards compliance and advanced features.

What Each One Is

🟦 Microsoft Dataverse

  • A cloud-based data platform used by Power Apps, Power Automate, Dynamics 365.
  • Not just a database—includes security, business rules, API layer, auditing, integration, and a managed schema.
  • Under the hood uses Azure SQL, Cosmos DB, and Azure Blob Storage.

🟥 Microsoft SQL Server

  • A full-featured relational database management system (RDBMS).
  • Commercial licensing, strong enterprise tooling, and deep integration with Azure, .NET, Windows Server.
  • Supports OLTP, analytics, and BI workloads.

🟩 PostgreSQL

  • A free, open-source RDBMS with strong SQL standards compliance.
  • Known for extensibility (custom types, functions, extensions like PostGIS).
  • Competes directly with SQL Server in enterprise features without licensing fees.

Comparison Table

Feature / AspectDataverseSQL ServerPostgreSQL
Primary PurposeLow‑code app data platformEnterprise RDBMSOpen‑source enterprise RDBMS
Best ForPower Platform & Dynamics appsEnterprise apps, BI, Microsoft stackCross‑platform apps, open-source ecosystems
HostingFully managed SaaSOn‑prem, Azure, hybridOn‑prem, cloud (AWS, Azure, GCP), hybrid
LicensingPer‑user/app licensingCommercial licensesFree (open source)
ExtensibilityLimited (managed schema)HighVery high (extensions, custom types)
APIsBuilt‑in REST, ODataRequires custom API layerRequires custom API layer
Security ModelRow-level, role-based, built-inHighly configurableHighly configurable
Performance ControlLimited (managed)Full controlFull control
Use in Power PlatformNativeRequires connectorsRequires connectors

Key Differences Explained

1. Purpose & Abstraction Level

  • Dataverse abstracts away database management. You don’t manage tables, indexes, or backups—Microsoft does.
  • SQL Server and PostgreSQL give you full control over schema, performance tuning, and infrastructure.

2. Integration

  • Dataverse is the default data layer for Power Apps and Dynamics 365.
  • SQL Server integrates deeply with Microsoft tools (SSIS, SSRS, Azure Synapse).
  • PostgreSQL integrates broadly across open-source ecosystems and cloud platforms.

3. Cost Model

  • Dataverse: Licensing based on Power Platform usage (can get expensive at scale).
  • SQL Server: Licensing per core or CAL.
  • PostgreSQL: Free, with optional paid support.

4. Flexibility

  • Dataverse: Highly opinionated; great for business apps but restrictive for custom architectures.
  • SQL Server: Flexible but within Microsoft’s ecosystem.
  • PostgreSQL: Most flexible—extensions, custom data types, procedural languages.

5. Scalability

  • Dataverse: Scales automatically but within platform limits.
  • SQL Server: Scales vertically and horizontally (with Always On, sharding patterns).
  • PostgreSQL: Scales well; many cloud providers offer managed scaling.

When to Use Each

Choose Dataverse if:

  • You’re building Power Apps, Power Automate, or Dynamics 365 solutions.
  • You want zero database administration.
  • You need built‑in security, auditing, business rules, and managed APIs.

Choose SQL Server if:

  • You’re in a Microsoft-centric enterprise.
  • You need high-performance OLTP, BI, or analytics.
  • You want tight integration with Azure and .NET.

Choose PostgreSQL if:

  • You want open-source, cost-effective, and highly extensible technology.
  • You need advanced SQL features or geospatial support (PostGIS).
  • You want cloud portability (AWS, Azure, GCP).

How to Decide Quickly

Check the below…ask yourself…the following questions…

  1. Are you building Power Platform apps? → Use Dataverse.
  2. Are you building enterprise apps in the Microsoft ecosystem? → Use SQL Server.
  3. Do you want open-source, flexible, and cloud-portable? → Use PostgreSQL.

References:

https://www.postgresql.org/

https://community.powerplatform.com/blogs/post/?postid=5751807c-dc27-4b47-8357-cb33cd07dbe3&utm_source=copilot.com

Cheers,

PMDY

Why Microsoft Support Asks for a HAR File …?

Hello Microsoft Folks,

Everyone in their career will reach a point. At this stage, the next step is to raise a Microsoft Support ticket to report any product issue — particularly for Power Apps implementations, as we did recently.

Microsoft Support generally asks to send a HAR File to escalate issues to the Product team. In this blog post today, let’s understand what a HAR File is and why the MS Product team needs it.

A HAR file (HTTP Archive) is a diagnostic capture of everything your browser does during a web session. It includes network calls, payloads, headers, and timings. It also encompasses redirects, failures, and more.

You raise a ticket for Power Apps, Power Automate, or Power BI Service. The product team often needs more than just screenshots. They need detailed information. They can’t reproduce the issue with just images. They need to see exactly what your browser saw.

What a HAR File Includes.. and why Microsoft Product team needs it??

  • Think of it as a flight recorder for your browser:
  • Network requests Every API call your browser makes
  • Failing endpoints or throttling
  • Ask/response headers Auth tokens, cookies, metadata To check authentication, region routing, tenant context
  • Payloads JSON bodies sent/received To see malformed data, schema mismatches, or server errors
  • Timings DNS, SSL, wait time, download time To diagnose latency, timeouts, or CDN issues
  • Errors 4xx/5xx responses To pinpoint backend failures

This is the only way the engineering team can see the real sequence of events that caused your issue.

 Why It’s Critical for Power Platform Issues

Especially in Power Platform, a HAR file helps diagnose:

• Connector calls failing due to throttling
• Canvas app load failures
• Dataverse API errors
• Authentication loops (AAD, MSAL, cookies)
• Portal/Power Pages rendering issues
• Power BI embedded or service-side failures
• Browser-specific regressions
• Region misrouting or CDN cache issues

You’ve probably seen cases where the UI shows a generic message like Something went wrong.

The HAR file reveals the actual error behind it.

 Is It Safe?

A HAR file can contain sensitive data (tokens, cookies, request bodies).
That’s why Microsoft always asks you to:

• Reproduce the issue in a test environment if possible
• Scrub sensitive fields if needed
• Upload via the secure support portal

Microsoft support uses it only for debugging and deletes it after the case is resolved.

 With a HAR file, MS Engineers can:

• Reproduce the issue in their internal environment
• Identify whether the problem is client-side, network-side, or server-side
• Trace the exact failing API
• Confirm whether it’s a regression, configuration issue, or tenant-specific problem
• Escalate to the product group with concrete evidence

Now you have understood the purpose of the HAR file, use the below link to generate the same

https://learn.microsoft.com/en-us/azure/azure-portal/capture-browser-trace

Cheers,

PMDY

Understanding Dataverse MCP vs Power Apps MCP – Quick Review

Hi Folks,

Model Context Protocol(MCP) has quickly become one of the hottest topics in today’s AI landscape. The excitement around it is huge—not just within the Microsoft ecosystem, but across the entire industry, because it’s designed to be open and accessible to everyone.

Microsoft Power Platform is also moving fast, releasing its own MCPs. I’ve already been asked several times about the difference between them, so this post breaks down how the Dataverse MCP and the Power Apps MCP differ—and when you should use each one.

We know that Dataverse MCP is generally available last year. Now Microsoft announced the public preview of Power Apps MCP this month. So what’s the difference between the two, this post will help to discern the differences between two.

Although both use the Model Context Protocol (MCP), they serve different purposes and operate at different layers of the Power Platform.

FeatureDataverse MCPPower Apps MCP
Primary RoleExpose Dataverse as an MCP server so AI agents can query tables, records, and metadataAllow Power Apps to use MCP to call external AI models or tools
FocusData access & operationsAI integration inside apps
Who Uses ItDevelopers building AI agents or copilots that need Dataverse dataApp makers building Power Apps that need AI-driven logic

2. Direction of Integration

DirectionDataverse MCPPower Apps MCP
MCP ServerYes — Dataverse acts as an MCP serverNo
MCP ClientNoYes — Power Apps acts as an MCP client
MeaningAI tools connect into DataversePower Apps connects out to AI tools

Dataverse MCP: AI → Dataverse Power Apps MCP: Power Apps → AI

3. What You Can Do

Dataverse MCP

  • Query Dataverse tables
  • Retrieve records
  • Update or create data
  • Use Dataverse as a tool inside Copilot Studio, VS Code GitHub Copilot, Claude Desktop, etc.

Power Apps MCP

  • Call external AI models from inside a Power App
  • Build AI-driven app logic
  • Trigger workflows using AI reasoning

4. Typical Use Cases

Dataverse MCP

  • Build a Copilot that answers questions using Dataverse data
  • Let GitHub Copilot query Dataverse while coding
  • Create AI agents that read/write CRM or ERP data

Power Apps MCP

  • Add AI reasoning to a canvas or model-driven app
  • Use external AI models to classify, summarize, or generate content
  • Build intelligent forms or workflows

5. Relation to Connectors

Dataverse MCP is increasingly seen as a future alternative to connectors for AI-driven scenarios.

Power Apps MCP does not replace connectors — it extends apps with AI capabilities.

Summary

CategoryDataverse MCPPower Apps MCP
Acts asMCP ServerMCP Client
Used forAI agents accessing DataversePower Apps calling AI tools
Primary BenefitIntelligent, standardized Dataverse accessAI-enhanced app logic
Typical ToolsCopilot Studio, GitHub Copilot, ClaudeCanvas apps, model-driven apps

Decision Guide: When to Use Dataverse MCP vs Power Apps MCP

1. If you want AI to access Dataverse → Use Dataverse MCP

Choose Dataverse MCP when:

  • You’re building a Copilot, AI agent, or LLM-powered tool that needs:
    • Dataverse tables
    • Records
    • Metadata
    • CRUD operations
  • You want AI to reason over business data
  • You want a standardized, connector-free way for AI to talk to Dataverse
  • You’re integrating Dataverse with:
    • GitHub Copilot
    • Copilot Studio
    • Claude Desktop
    • Custom LLM agents

Typical scenarios

  • My AI assistant should answer questions using CRM data.
  • I want GitHub Copilot to autocomplete code based on Dataverse schema.
  • I’m building an AI agent that updates Dataverse records.

If the AI is the one doing the work → Dataverse MCP.

2. If you want your Power App to call AI → Use Power Apps MCP

Choose Power Apps MCP when:

  • You’re building a canvas or model-driven app that needs:
    • AI reasoning
    • AI-generated content
    • AI classification or summarization
  • You want your app to call:
    • OpenAI models
    • Azure AI models
    • Custom MCP tools
  • You want AI logic inside the app, not outside it

Typical scenarios

  • My form should summarize customer notes using AI.
  • My app should classify images or text using an external model.
  • I want to call an LLM from a button in a canvas app.

3. If you need both directions → Use both

Some solutions need AI ↔ Dataverse ↔ Power Apps.

Example

  • A Power App collects data
  • AI agent (via Dataverse MCP) analyzes historical records
  • Power App (via Power Apps MCP) calls AI to generate insights for the user

This is becoming a common pattern in enterprise AI.

4. Quick Decision Table

GoalUse Dataverse MCPUse Power Apps MCP
AI needs to read/write Dataverse✅❌
Power App needs to call AI❌✅
Replace connectors for AI-driven data access✅❌
Add AI reasoning inside app UI❌✅
Build AI copilots or agents✅❌
Build AI-enhanced business apps❌✅

Hope you have found this post useful….

Cheers,

PMDY

Python + Dataverse Series – #07: Running a Linear Normalization Algorithm on Dataverse Data Using Python

This is continuation in this series of Dataverse SDK for Python, if you haven’t checked out earlier articles, I would encourage to start from the beginning of this series.

Python + Dataverse Series – How to run Python Code in Vs Code

Machine learning often begins with one essential step: data preprocessing. Before models can learn patterns, the raw data must be cleaned, scaled, and transformed into a form suitable for analysis. In this example, let me demonstrate how to retrieve numerical data from Microsoft Dataverse and apply a linear normalization algorithm using Python.

Normalization is a fundamental algorithm in machine learning pipelines. It rescales numeric values into a consistent range—typically between 0 and 1—making them easier for algorithms to interpret and compare.

1. Retrieving Data from Dataverse

Using the DataverseClient and Interactive Browser authentication, we connect to Dataverse and fetch the revenue field from the Account table. This gives us a small dataset to run our algorithm on.

from azure.identity import InteractiveBrowserCredential 
from PowerPlatform.Dataverse.client import DataverseClient  
credential = InteractiveBrowserCredential()
client = DataverseClient("https://ecellorsdev.crm8.dynamics.com", credential)
account_batches = client.get(
    "account",
    select=["accountid", "revenue"],
    top=10,
)

We then extract the revenue values into a NumPy array.

2. Implementing the Linear Normalization Algorithm

The algorithm used here is min–max normalization, defined mathematically as:normalized=x−min⁡(x)max⁡(x)−min⁡(x)This algorithm ensures:

  • the smallest value becomes 0
  • the largest becomes 1
  • all other values fall proportionally in between

Here’s the implementation:

import numpy as np
revenues = np.array(revenues)
min_rev = np.min(revenues)
max_rev = np.max(revenues)
normalized_revenues = (revenues - min_rev) / (max_rev - min_rev)

This is a classic preprocessing algorithm used in machine learning pipelines before feeding data into models such as regression, clustering, or neural networks.

3. Visualizing the Normalized Output

To better understand the effect of the algorithm, we plot the normalized values:

import matplotlib.pyplot as plt 
plt.plot(normalized_revenues, marker='o')
plt.title('Normalized Revenues from Dataverse Accounts')
plt.xlabel('Account Index')
plt.ylabel('Normalized Revenue')
plt.grid()
plt.show()

The visualization highlights how the algorithm compresses the original revenue values into a uniform scale.

4. Why Normalization Matters

Normalization is not just a mathematical trick—it’s a crucial algorithmic step that:

  • prevents large values from dominating smaller ones
  • improves convergence in optimization-based models
  • enhances the stability of distance‑based algorithms
  • makes datasets comparable across different ranges
#Running Machine Learning Algorithm on data retrieved from Dataverse to run a linear normalization
from azure.identity import InteractiveBrowserCredential
from PowerPlatform.Dataverse.client import DataverseClient
import numpy as np
# Connect to Dataverse
credential = InteractiveBrowserCredential()
client = DataverseClient("https://ecellorsdev.crm8.dynamics.com", credential)
# Fetch account data as paged batches
account_batches = client.get(
"account",
select=["accountid", "revenue"],
top=10,
)
revenues = []
for batch in account_batches:
for account in batch:
if "revenue" in account and account["revenue"] is not None:
revenues.append(account["revenue"])
revenues = np.array(revenues)
# Apply a simple linear algorithm: Normalize the revenues
if len(revenues) > 0:
min_rev = np.min(revenues)
max_rev = np.max(revenues)
normalized_revenues = (revenues – min_rev) / (max_rev – min_rev)
print("Normalized Revenues:", normalized_revenues)
#visualize the result
import matplotlib.pyplot as plt
plt.plot(normalized_revenues, marker='o')
plt.title('Normalized Revenues from Dataverse Accounts')
plt.xlabel('Account Index')
plt.ylabel('Normalized Revenue')
plt.grid()
plt.show()
view raw Python-RetrieveData-ApplyLinearAlgorithm hosted with ❤ by GitHub

The use of this code is to transform raw Dataverse revenue data into normalized, machine‑learning‑ready values that can be analyzed, compared, and visualized effectively.

You can download the Python Notebook below if you want to work with VS Code

https://github.com/pavanmanideep/DataverseSDK_PythonSamples/blob/main/Python-RetrieveData-ApplyLinearAlgorithm.ipynb

Once you have opened the Python notebook, you can start to run the code as below

You should see something like below

For authentication in another browser tab, once authenticated, you should be able to see the

Hope you found this useful…it’s going to be interesting, stay tuned for upcoming articles.

Cheers,

PMDY

Python + Dataverse Series – #06: Data preprocessing steps before running Machine Learning Algorithms

Hi Folks,

If you were already a Power Platform Consultant and new to working with Python, then I would encourage to start from the beginning of this series.

Python + Dataverse Series – How to run Python Code in Vs Code

Now in this series, we entered an interesting part where Machine learning algorithms were run to analyze Dataverse Data and in this post we will understand why feature scaling is a critical preprocessing step for many machine learning algorithms because it ensures that all features contribute equally to the model’s outcome, prevents numerical instability, and helps optimization algorithms converge faster to the optimal solution

Primarily before running any Machine Learning Algorithm, we need to do some data preprocessing like scaling the data, in this case we will use a formula which is used to scale using min–max normalization (feature scaling to the [0, 1] range).

#preprocessing step before running machine learning algorithms
from azure.identity import InteractiveBrowserCredential #using Interactive Login
from PowerPlatform.Dataverse.client import DataverseClient #installing Python SDK for Dataverse
import numpy as np #import Numpy Library to perform calculations
# Connect to Dataverse
credential = InteractiveBrowserCredential()
client = DataverseClient("https://ecellorsdev.crm8.dynamics.com", credential) #Creates Dataverse Client
# Fetch account data as paged batches
account_batches = client.get(
"account",
select=["accountid", "revenue"],
top=10,
) #Fetches top 10 accounts with accountid, revenue columns
revenues = []
for batch in account_batches:
for account in batch:
if "revenue" in account and account["revenue"] is not None:
revenues.append(account["revenue"])
revenues = np.array(revenues)
#Normalize the revenue
if len(revenues) > 0:
min_rev = np.min(revenues)
max_rev = np.max(revenues)
normalized_revenues = (revenues – min_rev) / (max_rev – min_rev)
print("Normalized Revenues:", normalized_revenues)
#visualize the result
import matplotlib.pyplot as plt
plt.plot(normalized_revenues, marker='o')
plt.title('Normalized Revenues from Dataverse Accounts')
plt.xlabel('Account Index')
plt.ylabel('Normalized Revenue')
plt.grid()
plt.show()
view raw preprocessing step before running machine learning algorithms hosted with ❤ by GitHub

You can download the Python Notebook below if you want to work with VS Code

https://github.com/pavanmanideep/DataverseSDK_PythonSamples/blob/main/Python-PreProcessingStepBeforeMachineLearning.ipynb

Hope you found this useful…

Cheers,

PMDY

Python + Dataverse Series – How to run Python Code in Vs Code

Hi Folks,

As you folks know that Python currently is the number #1 programming language with a massive, versatile ecosystem of libraries for data science, AI, and backend web development. This post kicks off a hands‑on series about working with Microsoft Dataverse using Python. We’ll explore how to use the Dataverse SDK for Python to connect with Dataverse, automate data operations, and integrate Python solutions across the broader Power Platform ecosystem. Whether you’re building data-driven apps, automating workflows, or extending Power Platform capabilities with custom logic, this series will help you get started with practical, real‑world examples.

https://www.microsoft.com/en-us/power-platform/blog/2025/12/03/dataverse-sdk-python/

With the release of the Dataverse SDK for Python, building Python-based logic for the Power Platform has become dramatically simpler. In this post, we’ll walk through how to download Python and set it up in Visual Studio Code so you can start building applications that interact with Dataverse using Python. Sounds exciting already. Let’s dive in and get everything set up..

1. Download and install Python from official website below and then install it in your computer.

https://www.python.org/ftp/python/3.14.3/python-3.14.3-amd64.exe

2. Install VS Code

Important: During installation, make sure to check “Add Python to PATH”. This ensures VS Code can detect Python automatically.

3. After installation, open VS Code and install the Python extension (Microsoft’s official one). This extension enables IntelliSense, debugging, and running Python script

4. That’s it, you are now able to run Python logic inside Vs Code

5. Create or Open a Python file in the system, opened a sample file below

5. If you want to run Python Programmes in your VS Code, follow below options

a. Select Start Debugging

b. You will be prompted a window like below

You can select the first option highlighted above, it automatically runs your Python Code

This is very easy to setup…

If you want to continue reading this series, check out the next article.

Python + Dataverse Series – #01 – Console Application using Python

Hope this helps…

Cheers,

PMDY

Python + Dataverse Series – #05: Remove PII

Hi Folks,

This is in continuation in the Python + Dataverse series, it is worth checking out from the start of this series here.

At times, there will be a need to remove PII(Personally Identifiable Information) present in the Dataverse Environments, for this one time task, you can easily run Python script below, let’s take example of removing PII from Contact fields in the below example.

from azure.identity import InteractiveBrowserCredential
from PowerPlatform.Dataverse.client import DataverseClient
# Connect to Dataverse
credential = InteractiveBrowserCredential()
client = DataverseClient("https://ecellorsdev.crm8.dynamics.com", credential)
#use AI to remove PII data from the dataverse records, let's say contact records
def remove_pii_from_contact(contact):
pii_fields = ['emailaddress1', 'telephone1', 'mobilephone', 'address1_line1', 'address1_city', 'address1_postalcode']
for field in pii_fields:
if field in contact:
contact[field] = '[REDACTED]'
return contact
# Fetch contacts with PII (Dataverse client returns paged batches)
contact_batches = client.get(
"contact",
select=[
"contactid",
"fullname",
"emailaddress1",
"telephone1",
"mobilephone",
"address1_line1",
"address1_city",
"address1_postalcode",
],
top=10,
)
# Remove PII and update contacts
for batch in contact_batches:
for contact in batch:
contact_id = contact.get("contactid")
sanitized_contact = remove_pii_from_contact(contact)
# Prepare update data (exclude contactid)
update_data = {key: value for key, value in sanitized_contact.items() if key != "contactid"}
# Update the contact in Dataverse
client.update("contact", contact_id, update_data)
print(f"Contact {contact_id} updated with sanitized data: {sanitized_contact}")
view raw Easy way to remove PII in Dataverse using Python hosted with ❤ by GitHub

If you want to work on this, download the Python Notebook to use in VS Code…

https://github.com/pavanmanideep/DataverseSDK_PythonSamples/blob/main/Python-DataverseSDK-RemovePII.ipynb

Cheers,

PMDY

Understanding MIME Types in Power Platform – Quick Review

While many people doesn’t know the significance of MIME Type, this post is to give brief knowledge about the same before moving to understand security concepts in Power Platform in my upcoming articles.

In the Microsoft Power Platform, MIME types (Multipurpose Internet Mail Extensions) are standardized labels used to identify the format of data files. They are critical for ensuring that applications like Power Apps, Power Automate, and Power Pages can correctly process, display, or transmit files. 

Core Functions in Power Platform

  • Dataverse Storage: Tables such as ActivityMimeAttachment and Annotation (Notes) use a dedicated MimeType column to store the format of attached files alongside their Base64-encoded content.
  • Security & Governance: Administrators can use the Power Platform Admin Center to block specific “dangerous” MIME types (e.g., executables) from being uploaded as attachments to protect the environment.
  • Power Automate Approvals: You can configure approval flows to fail if they contain blocked file types, providing an extra layer of security for email notifications.
  • Power Pages (Web Templates): When creating custom web templates, the MIME type field controls how the server responds to a browser. For example, templates generating JSON must be set to application/json to be parsed correctly.
  • Email Operations: When using connectors like Office 365 Outlook, you must specify the MIME type for attachments (e.g., application/pdf for PDFs) so the recipient’s client can open them properly. 

Common MIME Types Used

File Extension MIME Type
.pdfapplication/pdf
.docxapplication/vnd.openxmlformats-officedocument.wordprocessingml.document
.xlsxapplication/vnd.openxmlformats-officedocument.spreadsheetml.sheet
.png / .jpgimage/png / image/jpeg
.jsonapplication/json
Unknownapplication/octet-stream (used for generic binary files)

Implementing MIME type handling and file restrictions ensures your Power Platform solutions are both functional and secure.

1. Programmatically Setting MIME Types in Power Automate 

When working with file content in Power Automate, you often need to define the MIME type within a JSON object so connectors (like Outlook or HTTP) understand how to process the data. 

  • Structure: Use a Compose action to build a file object with the $content-type (MIME type) and $content (Base64 data).json
  • Dynamic Mapping: If you don’t know the file type in advance, you can use an expression to map extensions to MIME types or use connectors like Cloudmersive to automatically detect document type information. 

2. Restricting File Types in Power Apps

The Attachment control in Power Apps does not have a built-in “allowed types” property, so you must use Power Fx formulas to validate files after they are added. 

  • Validation on Add: Use the OnAddFile property of the attachment control to check the extension and notify the user if it’s invalid in PowerApps
  • Submit Button Logic: For added security, set the DisplayMode of your Submit button to Disabled if any attachment in the list doesn’t match your criteria. 

3. Global Restrictions (Admin Center)

To enforce security across the entire environment, administrators can navigate to the Power Platform Admin Center to manage blocked MIME types. Adding an extension to the blocked file extensions list prevents users from uploading those file types to Dataverse tables like Notes or email attachments. 

Hope this helps…in next post, I will be talking about Content Security Policy and how Power Platform can be secured using different sets of configuration.

Cheers,

PMDY

Adding intelligence to Dataverse using Dataverse AI functions

Hi Folks,

While intelligence with the use of AI is being embedded into each and every part of the Microsoft ecosystem, it is good to know the features coming in the Power Platform space.

In this blog post, let’s see how we can use Dataverse AI Functions, their usage, advantages which can greatly ease summarizing, classifying, extracting, translating, assessing sentiment, or drafting a reply for common business scenarios.

To illustrate it better, I used a different AI Function for Canvas App, Model Driven App and Power Automate, hope you can follow the same for others as well.

What are Dataverse AI Functions?

Think of Dataverse AI Functions as prebuilt AI Functions which will add intelligence in your Apps and Flows without need to collect, build and train the models. They can be used in many places such as AI Builder, Power Automate, Power Apps, Low Code Plugins. Following are the AI Functions available…

  1. AIReply – Drafts a reply to the message you provide.
  2. AISentiment – Detects sentiment for the text you provide
  3. AISummarize – Summarizes the text you provide
  4. AIClassify – Classifies the text into one or more categories, you can use this from custom copilot
  5. AIExtract – Extracts specified entities like Names of people, phone numbers, places etc.
  6. AITranslate – Translate text from another language

Let’s see their usage in our favorite Canvas Apps first as illustration is easy and later in the post, I will mention how you can call the Dataverse AI Functions from Model Driven Apps, Power Automate so that you can get the real essence of it….

Utilizing ‘Dataverse AI Functions’ in a Canvas App

Create a new Canvas App and add ‘Environment’ Datasource as shown below.

All the ‘Dataverse AI functions’ can be accessed by ‘Environment‘ as shown below.

Let’s try the AIReply function in Canvas Apps

Add a textbox for storing the prompt or input string and a button control.

On the ‘OnSelect‘ event of the button, use the following formula to store the response in the AIResponse context variable, make sure you name the variables appropriately in your formula as per your naming defined in canvas apps.

UpdateContext({AIReplyResponse:Environment.AIReply({Text:AIInput.Text})})
view raw Dataverse AI Function hosted with ❤ by GitHub

Now create one more text variable to store the response and change the Default value to AIReplyResponse.PreparedResponse.

Try testing the app by providing inputs as below…

You should get a response from AIReply in the response field, you can try out other functions providing the necessary parameters required.

Utilizing ‘Dataverse AI Functions’ in a Power Automate

In Power Automate, all you can do to call Dataverse AI Functions is call the Unbound Action as below.

Passing the relevant input parameters is enough to get the output from these functions.

Let’s try AISentiment

Click on test, you should a response from Power Automate with the sentiment

Utilizing ‘Dataverse AI Functions’ in a Model Driven Apps

Do you want to utilize the similar capabilities of Dataverse AI Functions inside your custom code like in Plugins, Actions etc..

Let’s try AIClassify

var request = new OrganizationRequest("AIClassify")
{
["AllowMultipleCategories"] = false,
["Categories"] = titles,
["Text"] = classifyText
};
var result = service.Execute(request);
view raw DataverseFunctions.cs hosted with ❤ by GitHub

It was pretty much similar in AIBuilder as well…

Please do note that there are quotas to use these AI Functions at tenant level, else you might get similar error like below, while I didn’t get any information regarding this from Microsoft, so I am unsure about this as of writing this post, I will keep this updated if I get to know.

Using Dataverse AI functions needs a bit of Prompt Engineering knowledge, you were looking to learn more about Prompt engineering, then check it out here.

References:

https://learn.microsoft.com/en-us/power-platform/power-fx/reference/function-ai

Cheers,

PMDY