Power Platform# – ECELLORS CRM Blog

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 = \frac{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 – #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&quot;, 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
.pdf	`application/pdf`
.docx	`application/vnd.openxmlformats-officedocument.wordprocessingml.document`
.xlsx	`application/vnd.openxmlformats-officedocument.spreadsheetml.sheet`
.png / .jpg	`image/png` / `image/jpeg`
.json	`application/json`
Unknown	`application/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

Agentic AI Business Solutions Architect Exam -AB 100 Experience

Hi Folks,

On 14 November, 2025, I took the AB 100 Exam, this post is to share my experience about this exam.

The exam doesn’t look difficult or tricky to me, it feels like a lot to read in short amount of time. Most of the questions revolved around Copilot Studio, Azure AI Foundry, Azure Services for tracking telemetry, Copilot, Dynamics 365 Customer Engagement, Finance and Operations, Supply Chain Management.

While there is nitty-gritty on using Prebuilt agents and Custom Agents using Azure AI Foundry and Agent Governance, choosing right agent for the need but note that no question came up from AI Builder, Licensing as well.

However there were also scenario based questions on strategy using right tool for the need to build agent e.x. Azure Cloud Adoption Framework, Power Platform Well Architected Framework.

As per Exam NDA, exact exam questions may not be shared publicly, I am sharing my experience so that someone preparing for this exam can use this while preparing for taking this exam.

If you want to learn further, you can go through the below link which was recently created by Microsoft….go take a look…

AB 100 Collection

Hope it helps..

Cheers,

PMDY

Python + Dataverse Series – #04: Create records in batch using Execute Multiple

Hi Folks,

This is continuation in this Python with Dataverse Series, in this blog post, we will see how can we create multiple records in a single batch using ExecuteMultiple in Python.

Please use the below code for the same…to make any calls using ExecuteMultiple…

	import pyodbc
	import msal
	import requests
	import json
	import re
	import time

	# Azure AD details
	client_id = '0e1c58b1-3d9a-4618-8889-6c6505288d3c'
	client_secret = 'qlU8Q~dmhKFfdL1ph2YsLK9URbhIPn~qWmfr1ceL'
	tenant_id = '97ae7e35-2f87-418b-9432-6733950f3d5c'
	authority = f'https://login.microsoftonline.com/{tenant_id}'
	resource = 'https://ecellorsdev.crm8.dynamics.com'

	# SQL endpoint
	sql_server = 'ecellorsdev.crm8.dynamics.com'
	database = 'ecellorsdev'

	# Get token with error handling
	try:
	print(f"Attempting to authenticate with tenant: {tenant_id}")
	print(f"Authority URL: {authority}")

	app = msal.ConfidentialClientApplication(client_id, authority=authority, client_credential=client_secret)

	print("Acquiring token…")

	token_response = app.acquire_token_for_client(scopes=[f'{resource}/.default'])

	if 'error' in token_response:
	print(f"Token acquisition failed: {token_response['error']}")
	print(f"Error description: {token_response.get('error_description', 'No description available')}")
	else:
	access_token = token_response['access_token']
	print("Token acquired successfully and your token is!"+access_token)
	print(f"Token length: {len(access_token)} characters")

	except ValueError as e:
	print(f"Configuration Error: {e}")

	except Exception as e:
	print(f"Unexpected error: {e}")

	#Get 5 contacts from Dataverse using Web API
	import requests
	import json

	try:
	#Full CRUD Operations – Create, Read, Update, Delete a contact in Dataverse
	print("Making Web API request to perform CRUD operations on contacts…")

	# Dataverse Web API endpoint for contacts
	web_api_url = f"{resource}/api/data/v9.2/contacts"

	# Base headers with authorization token
	headers = {
	'Authorization': f'Bearer {access_token}',
	'OData-MaxVersion': '4.0',
	'OData-Version': '4.0',
	'Accept': 'application/json',
	'Content-Type': 'application/json'
	}

	# Simple approach: create multiple contacts sequentially
	# generate 100 contacts with different last names
	contacts_to_create = [
	{"firstname": "Ecellors", "lastname": f"Test{str(i).zfill(3)}"}
	for i in range(1, 101)
	]

	create_headers = headers.copy()
	create_headers['Prefer'] = 'return=representation'

	created_ids = []
	print("Creating contacts sequentially…")
	for i, body in enumerate(contacts_to_create, start=1):
	try:
	resp = requests.post(web_api_url, headers=create_headers, json=body, timeout=15)
	except requests.exceptions.RequestException as e:
	print(f"Request error creating contact #{i}: {e}")
	continue

	if resp.status_code in (200, 201):
	try:
	j = resp.json()
	cid = j.get('contactid')
	except ValueError:
	cid = None

	if cid:
	created_ids.append(cid)
	print(f"Created contact #{i} with id: {cid}")

	else:
	print(f"Created contact #{i} but response body missing id. Response headers: {resp.headers}")

	elif resp.status_code == 204:
	# try to extract id from headers
	entity_url = resp.headers.get('OData-EntityId') or resp.headers.get('Location')

	if entity_url:
	m = re.search(r"([0-9a-fA-F\-]{36})", entity_url)
	if m:
	cid = m.group(1)
	created_ids.append(cid)
	print(f"Created contact #{i} (204) with id: {cid}")
	else:
	print(f"Created contact #{i} (204) but couldn't parse id from headers: {resp.headers}")
	else:
	print(f"Created contact #{i} (204) but no entity header present: {resp.headers}")
	else:
	print(f"Failed to create contact #{i}. Status code: {resp.status_code}, Response: {resp.text}")

	# small pause to reduce chance of throttling/rate limits
	time.sleep(0.2)

	if created_ids:
	print("Created contact ids:")
	for cid in created_ids:
	print(cid)

	except Exception as e:
	print(f"Unexpected error during Execute Multiple: {e}")
	print("Failed to extract Contact ID from headers.")

view raw Python – Dataverse – ExecuteMultipleCreate hosted with ❤ by GitHub

Please download this Jupyter notebook to work on it easily using VS Code.

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

If you want to continue reading this series, follow along

Python + Dataverse Series – #05: Remove PII

Hope this helps..

Cheers,

PMDY

Want to check if you have added metadata to the entity in Power Apps – Table Segmentation properties?

Hi Folks,

After a break, I am back with my next blog post, this is a very short one.

Whenever you were working on any implementation, you could have added entity assets to the solution, many people miss adding metadata for the entity, since they don’t have a way to check properly, folks end up removing and readding the entity with metadata toggle on.

But don’t worry, here is a simple way to check this..

Let’s say you have added a table to the form like below

Now you want to add the metadata for this, click on the table name below

Click on Elipses…

Choose table segmentation as shown above

So as highlighted above, you can include all the objects or include table metadata.

Hope this small tip helps…so even if you miss adding metadata, you can safely add it later at any point of time.

Cheers,

PMDY

Power Platform Solution Blue Print Review – Quick Recap

The Solution blueprint review is covers all required topics. The workshop can also be conducted remotely. When the workshop is done remotely, it is typical to divide the review into several sessions over several days.

The following sections cover the top-level topics of the Solution blueprint review and provide a sampling of the types of questions that are covered in each section.

Program strategy

Program strategy covers the process and structures that will guide the implementation. It also reviews the approach that will be used to capture, validate, and manage requirements, and the plan and schedule for creation and adoption of the solution.