In Microsoft Dataverse, Power Automate flows are commonly used to execute business logic when records are created, updated, or deleted. They work well for most user-driven and real-time business operations.

However, in certain scenarios such as integrations, background jobs, bulk data operations, or system maintenance tasks running these flows is not always required and can negatively impact performance or cause unintended automation triggers.

To address this, Microsoft provides a way to bypass Power Automate flow execution when performing operations through the Dataverse SDK. This allows developers to update or delete records without triggering associated flows, giving greater control over when automation should or should not run.

In this blog, we’ll explore when and why bypassing Power Automate flows makes sense, how it works at a technical level, and what to keep in mind before using it in production environments.

Why Bypass Power Automate Flows?

Bypassing flows is useful when the operation is system-driven and the flow logic is not needed.

Some common reasons include:

• Avoiding unnecessary flow execution during background operations
• Improving performance during bulk updates or migrations
• Preventing flows from triggering repeatedly or causing loops
• Keeping business automation separate from technical or maintenance logic

This approach ensures that Power Automate flows run only when they genuinely add business value, rather than during behind-the-scenes system updates.

Steps to Perform

For demonstration purposes, the logic is implemented using a desktop application. The objective is to clearly compare a standard update operation with one that bypasses Power Automate flow execution.

In both scenarios:

• The same account record is updated
• The only difference is whether the bypass flag is applied during the update request

Update Event Without Bypass

In this scenario, the record is updated using the standard SDK request without any bypass flag.

/// <summary>

/// Update the record Account record

/// </summary>

/// <param name="service"></param>

private static void UpdateRecord(CrmServiceClient service, string accountName, Guid accountId)

{

try

{

//Step 1: Get Record to update

Entity ent = new Entity("account", accountId);

#region Create Account name

ent["name"] = accountName;

#endregion

// Step 2: Update

service.Update(ent);

Console.WriteLine($"Record updated successfully. {DateTime.Now}");

}

catch (Exception ex)

{

SampleHelpers.HandleException(ex);

}
}

Observed behavior:

• The update operation succeeds
• The associated Power Automate flow is triggered
• Any downstream logic defined in the flow executes as expected (for example, SharePoint operations, notifications, or validations)

This is the default and expected behavior when performing update operations through the SDK.

Update Event with Power Automate Flow Bypass

In this scenario, the same update operation is executed, but the request includes the bypass flag to skip Power Automate flow execution.

/// <summary>

/// Update the record Account record with bypass logic

/// </summary>

/// <param name="service"></param>

private static void UpdateRecordWithBypass(CrmServiceClient service, string accountName, Guid accountId)

{

try

{

//Step 1: Get Record to update

Entity ent = new Entity("account", accountId);

#region Create entity record object

ent["name"] = accountName;

#endregion

// Step 2: Create delete request

var updateRequest = new UpdateRequest

{

Target = ent

};

// Step 3: Bypass Power Automate flows

updateRequest.Parameters.Add("SuppressCallbackRegistrationExpanderJob", true);

// Step 4: Execute

service.Execute(updateRequest);

Console.WriteLine($"Record updated with bypass successfully. {DateTime.Now}");

}

catch (Exception ex)

{

SampleHelpers.HandleException(ex);

}
}

Observed behavior:

• The record is updated successfully.
• Power Automate flow does not execute.
• No SharePoint or automation logic tied to the flow is triggered.

This allows the system to perform controlled updates without affecting existing automation logic.

Conclusion

Bypassing Power Automate flows in Microsoft Dataverse is a powerful capability designed for advanced scenarios, such as:

• System integrations
• Maintenance or cleanup jobs
• Bulk updates and data migrations

When used appropriately, it helps improve performance, avoid unnecessary automation, and maintain clean separation between business logic and technical processes.

However, this feature should be applied carefully and intentionally. Overusing it can lead to missed automation or inconsistent system behavior. When used in the right context, it results in cleaner implementations and more predictable outcomes.

The post How to restrict Unwanted Power Automate flow execution first appeared on Microsoft Dynamics 365 CRM Tips and Tricks.

In today’s data-driven enterprises, critical business information often arrives in the form of PDFs—bank statements, invoices, policy documents, reports, and contracts. Although these files contain valuable information, turning them into structured, reusable data or finalized business documents often requires significant manual effort and is highly error-prone.
By leveraging Azure Document Intelligence (for PDF data extraction), Azure Functions (for custom business logic), and Power Automate (for workflow orchestration) together, businesses can create a seamless automation pipeline that interprets PDF content, transforms extracted information through business rules, and produces finalized documents automatically, eliminating repetitive manual work and improving overall efficiency.
In this blog, we will explore how these Azure services work together to automate document creation from business PDFs in a scalable and reliable way.

Use Case: Automatically Converting Bank Statement PDFs into CSV Files

Let’s consider a potential use case.
The finance team receives bank statements as PDF attachments in a shared mailbox on a regular basis. These statements contain transaction details in tabular format, but extracting the data manually into Excel or CSV files is time-consuming and often leads to formatting issues such as broken rows, missing dates, and incorrect debit or credit values.
The goal is to automatically process these emailed PDF bank statements as soon as they arrive, extract the transaction data accurately, and generate a clean, structured CSV file that can be directly used for reconciliation and financial reporting.
By using Power Automate to monitor incoming emails, Azure Document Intelligence to analyze the PDFs, and Azure Functions to apply custom data-cleaning logic, the entire process can be automated, eliminating manual effort and ensuring consistent, reliable output.
Let’s walk through the steps below to achieve this requirement.

Prerequisites:

Before we get started, we need to have the following things ready:
• Azure subscription.
• Access to Power Automate to create email-triggered flows.
• Visual Studio 2022

Step 1:

Navigate to the Azure portal (https://portal.azure.com), search for the Azure Document Intelligence service, and click Create to provision a new resource.

Step 2:

Choose Azure subscription 1 as the subscription, create a new resource group, enter an appropriate name for the Document Intelligence instance, select the desired pricing tier, and click Review + Create to proceed.

Step 3:

After reviewing the configuration, click Create and wait for the deployment to complete. Once the deployment is finished, select Go to resource.

Step 4:

Navigate to the newly created Document Intelligence resource, and make a note of the endpoint and any one of the keys listed at the bottom of the page.

Step 5:

Create a new Azure Function in Visual Studio 2022 using an HTTP trigger with the .NET isolated worker model, and add the following code.

[Function("PdfToCsvExtractor")]
public async Task Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequest req)
{
_logger.LogInformation("Form Recognizer extraction triggered.");

// Accept either multipart/form-data (file field) OR raw application/pdf bytes.
Stream pdfStream = null;

try
{
// If content-type is multipart/form-data => read form and file
if (req.HasFormContentType)
{
var form = await req.ReadFormAsync();
var file = form.Files?.FirstOrDefault();
if (file == null || file.Length == 0)
return new BadRequestObjectResult("No file was uploaded in the multipart form-data.");

pdfStream = new MemoryStream();
await file.CopyToAsync(pdfStream);
pdfStream.Position = 0;
}
else
{
// Otherwise expect raw PDF bytes with Content-Type: application/pdf
if (!req.Body.CanRead)
return new BadRequestObjectResult("Request body empty.");

pdfStream = new MemoryStream();
await req.Body.CopyToAsync(pdfStream);
pdfStream.Position = 0;
}

string endpoint = Environment.GetEnvironmentVariable("FORM_RECOGNIZER_ENDPOINT");
string key = Environment.GetEnvironmentVariable("FORM_RECOGNIZER_KEY");
if (string.IsNullOrEmpty(endpoint) || string.IsNullOrEmpty(key))
return new BadRequestObjectResult("Missing Form Recognizer environment variables.");

var credential = new AzureKeyCredential(key);
var client = new DocumentAnalysisClient(new Uri(endpoint), credential);

var operation = await client.AnalyzeDocumentAsync(
WaitUntil.Completed,
"prebuilt-document",
pdfStream
);
var result = operation.Value;
_logger.LogInformation("pdfstream: " + pdfStream);

_logger.LogInformation("Result: "+ result.Tables.ToList());

// returns raw JSON table data
var filteredTables = result.Tables.ToList());
if (filteredTables.Count == 0)
return new BadRequestObjectResult("No transaction table found.");

string csvOutput = BuildCsvFromTables(filteredTables);

var csvBytes = Encoding.UTF8.GetBytes(csvOutput);

var emailResult = await SendEmailWithCsvAsync(
_logger,
csvBytes,
"ExtractedTable.csv");

return new OkObjectResult(“Table data extracted and exported to csv file”);
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
return new StatusCodeResult(500);
}
finally
{
pdfStream?.Dispose();
}
}

//method to create csv file
private string BuildCsvFromTables(IReadOnlyList tables)
{
var csvBuilder = new StringBuilder();
// Write CSV header
csvBuilder.AppendLine("Date,Transaction,Debit,Credit,Balance");
foreach (var table in tables)
{
// Group cells by row index
var rows = table.Cells
.GroupBy(c => c.RowIndex)
.OrderBy(g => g.Key);
foreach (var row in rows)
{
// Skip header row (row index 0)
if (row.Key == 0)
continue;
var rowValues = new string[5];
foreach (var cell in row)
{
if (cell.ColumnIndex < rowValues.Length)
{
// Clean commas and line breaks for CSV safety
rowValues[cell.ColumnIndex] =
cell.Content.Replace(",", " ").Replace("\n", " ").Trim();
}
}
csvBuilder.AppendLine(string.Join(",", rowValues));
}
}
return csvBuilder.ToString();
}

// method to send csv file as an attachment to an email
public async Task SendEmailWithCsvAsync(
ILogger log,
byte[] csvBytes,
string csvFileName)
{
log.LogInformation("Inside AzureSendEmailOnSuccess");

string clientId = Environment.GetEnvironmentVariable("InogicFunctionApp_client_id");
string clientSecret =Environment.GetEnvironmentVariable("InogicFunctionApp_client_secret");
string tenantId = Environment.GetEnvironmentVariable("Tenant_ID");
string receiverEmail = Environment.GetEnvironmentVariable("ReceiverEmail");
string senderEmail = Environment.GetEnvironmentVariable("SenderEmail");

var missing = new List();

if (string.IsNullOrEmpty(clientId)) missing.Add(nameof(clientId));
if (string.IsNullOrEmpty(clientSecret)) missing.Add(nameof(clientSecret));
if (string.IsNullOrEmpty(tenantId)) missing.Add(nameof(tenantId));
if (string.IsNullOrEmpty(receiverEmail)) missing.Add(nameof(receiverEmail));
if (string.IsNullOrEmpty(senderEmail)) missing.Add(nameof(senderEmail));

if (missing.Count > 0)
{
return new BadRequestObjectResult(
new { message = "Missing: " + string.Join(", ", missing) }
);
}

var app = ConfidentialClientApplicationBuilder
.Create(clientId)
.WithClientSecret(clientSecret)
.WithAuthority($"https://login.microsoftonline.com/{tenantId}")
.Build();

var result = await app.AcquireTokenForClient(
new[] { "https://graph.microsoft.com/.default" })
.ExecuteAsync();

string token = result.AccessToken;

string emailBody =
"Hello,

"
+ "Please find attached the extracted CSV.

"
+ "Regards,
Inogic Developer.";

var attachment = new Dictionary<string, object>
{
{ "@odata.type", "#microsoft.graph.fileAttachment" },
{ "name", csvFileName },
{ "contentType", "text/csv" },
{ "contentBytes", Convert.ToBase64String(csvBytes) }
};

var emailPayload = new Dictionary<string, object>
{
{
"message",
new Dictionary<string, object>
{
{ "subject", "Extracted PDF Table CSV" },
{
"body",
new Dictionary<string, object>
{
{ "contentType", "HTML" },
{ "content", emailBody }
}
},
{
"toRecipients",
new[]
{
new Dictionary<string, object>
{
{
"emailAddress",
new Dictionary<string, object>
{
{ "address", receiverEmail }
}
}
}
}
},
{ "attachments", new[] { attachment } }
}
},
{ "saveToSentItems", "false" }
};

string json = JsonSerializer.Serialize(emailPayload);

using var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Authorization =
new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token);

var httpContent = new StringContent(json, Encoding.UTF8, "application/json");

var response = await httpClient.PostAsync(
$"https://graph.microsoft.com/v1.0/users/{senderEmail}/sendMail",
httpContent
);

if (response.IsSuccessStatusCode)
return new OkObjectResult("CSV Email sent successfully.");

string errorBody = await response.Content.ReadAsStringAsync();
log.LogError($"Graph Error: {response.StatusCode} - {errorBody}");
return new StatusCodeResult(500);
}

Step 6:

Build the Azure Function project in Visual Studio and publish it to the Azure portal.

Step 7:

Open https://make.powerautomate.com and create a new cloud flow using the When a new email arrives in a shared mailbox (V2) trigger. Enter the shared mailbox email address in Original Mailbox Address, and set both Only with Attachments and Include Attachments to Yes.

Step 8:

Add a Condition action to verify that the attachment type is PDF.

Step 9:

If the condition is met, in the Yes branch add the Get Attachment (V2) action. Configure Message Id using the value from the trigger and Attachment Id using the value from the current loop item and the email address of the shared mailbox.

Step 10:

Add a Compose action to convert the attachment content bytes to Base64 using the following expression:
base64(outputs(‘Get_Attachment_(V2)’)?[‘body/contentBytes’])

Step 11:

Add another Compose action to convert the Base64 output from the previous step into a string using:
base64ToString(outputs(‘Compose’))

Step 12:

Add an HTTP (Premium) action, set the method to POST, provide the URL of the published Azure Function, and configure the request body as shown below:

{
"$content-type": "application/pdf",
"$content": "@{outputs('Compose_2')}"
}

To test the setup, send an email to the shared mailbox with the sample PDF attached.
Note: For demonstration purposes, a simplified one-page bank statement PDF is used. Real-world bank statements may contain multi-page tables, wrapped rows, and inconsistent layouts, which are handled through additional parsing logic.

Input PDF file:

Output CSV file:

Conclusion:

This blog demonstrated how an email-driven automation pipeline can simplify the processing of business PDFs by converting them into structured, usable data.
By combining Power Automate for orchestration, Azure Functions for custom processing, and Azure Document Intelligence for AI-based document analysis, organizations can build scalable, reliable, and low-maintenance document automation solutions that eliminate manual effort and reduce errors.

Frequently Asked Questions:

1. What is Azure Document Intelligence used for?
Azure Document Intelligence is used to extract structured data from unstructured documents such as PDFs, images, invoices, receipts, contracts, and bank statements using AI models.

2. How does Azure Document Intelligence extract data from PDF files?
It analyzes PDF content using prebuilt or custom AI models to identify text, tables, key-value pairs, and document structure, and returns the extracted data in a structured JSON format.

3. Can Power Automate process PDF attachments automatically?
Yes. Power Automate can automatically detect incoming PDF attachments from email, SharePoint, or OneDrive and trigger workflows to process them using Azure services.

4. How do Azure Functions integrate with Power Automate?
Power Automate can call Azure Functions via HTTP actions, allowing custom business logic, data transformation, and validation to run as part of an automated workflow.

5. Is Azure Document Intelligence suitable for bank statements and invoices?
Yes. Azure Document Intelligence can accurately extract tables, transaction data, and key fields from bank statements, invoices, and other financial documents.

The post Automating Business PDFs Using Azure Document Intelligence and Power Automate first appeared on Microsoft Dynamics 365 CRM Tips and Tricks.

In today’s fast-paced digital world, automating repetitive tasks not only saves time but also significantly improves productivity. Microsoft now offers a powerful preview AI model that enables automatic generation of image descriptions using the AI Builder’s prebuilt Image Description model in Power Automate Flow.

This smart tool analyzes your images and generates easy-to-understand, meaningful descriptions. These descriptions are really helpful for organizing your files, sorting images, and making content more accessible, all without you having to do anything manually.

How the AI Builder Image Description Model Works

The AI Builder Image Description model uses advanced computer vision to understand what’s in an image and convert that visual content into meaningful text. This makes tasks like organizing files, generating metadata, creating reports, or improving accessibility much easier because the system provides clear descriptions instantly and automatically.

Here’s a breakdown of how the model works behind the scenes:

1. It analyzes the image and generates three key outputs:

• A description (English only): A simple, human-readable explanation of what the image contains.
• Tags: Keywords that highlight the main objects, themes, or concepts detected in the image.
• A confidence score: A percentage indicating how certain the model is about its description.

2. It supports only these image file formats:

.JPG, .JPEG, .PNG, and .BMP
Uploading any other format will cause the action to fail.

3. Image size requirements:

1. • Maximum file size: 4 MB
   • Minimum resolution: 50 × 50 pixels

4. Role and licensing requirement:

You only need the Basic User role to use this model inside a Power Automate flow with no special admin permissions required.

Important note:
This feature is currently in preview, which means it works reliably for simple descriptions but is not recommended for production use yet.

Prerequisites:

Before creating a flow using this model, ensure you have:

• Access to Microsoft Power Automate
• Access to Dataverse

Step-by-Step Guide: Automate Image Descriptions

1. Create a New Flow

• Sign in to your Dataverse
• Open Power Automate, and click Create → Instant cloud flow (or choose another flow type based on your use case).

2. Add File Input (Optional)

• In the trigger step, click Add an input → Select File.

• This allows you to upload an image manually when testing the flow.

3. Add the AI Builder Action

• Click New Step → Search for “AI Builder” → Select “Describe images (Preview)”.

• In the Image field, choose File Content from Dynamic Content.

4. Add Post-Processing Logic (Optional)

• Click once the description is generated, you can add further steps such as:
  • Storing the description in a database.
  • Sending an email notification.

5. Save and Test the Flow

• Click Save.
• Select Test → Manually, and upload an image when prompted.
• The flow will run and automatically generate a description, confidence score, and related Tags.

Important Consideration (as per Microsoft docs):
This AI Builder currently supports only the English language and the following image formats only: Jpeg, Png, Gif, Bmp. Uploading other file types will result in a failed operation.

This feature is still in preview and currently provides straightforward descriptions. However, in the future, it has the potential to generate more detailed and complex image descriptions.

When Should You Use the Image Description Model?
A common use case is when a user uploads product images to your system. Automatically generating a description helps:

• Product Image Metadata: Automatically generate captions for product images in catalogs.
• Accessibility: Provide alt-text for images on websites and in documents.
• Content Tagging: Tag images with relevant labels for smarter search.
• Surveillance or Monitoring: Describe visual scenes (people, objects, activity) for easier review or alerts.

FAQs

1. How does the AI Builder Image Description model help my workflow?
   It automatically scans your images and generates clear, meaningful descriptions along with tags and confidence scores. This means faster content organization, better accessibility, and zero manual effort.
2. What image formats can I upload?
   The model currently supports JPG, JPEG, PNG, and BMP files. Using any other format will stop the flow from running successfully.
3. Are there any image size limits I should know about?
   Yes, your image must be under 4 MB and at least 50 × 50 pixels. Staying within these limits ensures smooth processing.
4. Does it work with multiple languages?
   For now, it generates descriptions only in English, as highlighted in the blog.
5. Is this ready for production use?
   Not yet. Since the feature is still in preview, it’s ideal for testing, prototyping, and internal automation but not for mission-critical production scenarios.
6. Do I need admin rights to use this in my Power Automate flow?
   No. The Basic User role is all you need to start using the Image Description model, making it easy for anyone in your team to adopt.

Conclusion:
Power Automate’s Image Description prebuilt model makes it effortless to generate meaningful image descriptions — without writing a single line of code. Whether it’s for improving accessibility or automating content organization, this tool empowers you to streamline processes, save time, and increase efficiency.

The post How to Automate Image Descriptions with AI Builder in Power Automate first appeared on Microsoft Dynamics 365 CRM Tips and Tricks.

Introduction

In an earlier Inogic post, “Streamlining E-Signatures in Multi-Step Forms with Power Pages and DocuSign Integration”, Our previous post demonstrated how Power Pages and DocuSign integration streamlines multi-step client data entry and signature workflow.

In this article, we focus on the next step of how to use Power Automate together with DocuSign to automatically send e-signature documents to clients, track their status, and handle the entire workflow with minimal manual effort.

Manual signing can delay approvals and create unnecessary admin work. With Power Automate + DocuSign integration, you can instantly deliver documents for signature as soon as a new client record is created in CRM — and monitor their progress in real time.

Why This Automation Matters

Manual signing often results in missed deadlines and extra effort for both sides. Automating this process ensures every client receives their document immediately after being added to the CRM.

Using Power Automate and DocuSign together provides:

• Instant document delivery for signature as soon as a new client record is created
• Real-time visibility into the document’s progress (sent, viewed, signed).
• A digital record of every activity for complete transparency

It saves time while keeping every client interaction clear and professional.

Step-by-Step Guide: How to Set Up DocuSign Automation in Power Automate

Step 1: How to Prepare a DocuSign Template

1. Begin by setting up a template in DocuSign to define your document layout and signing fields. For detailed guidance, refer to the DocuSign Template Documentation

Step 2: Create an Automated Flow in Power Automate

1. In Power Automate, go to Create → Automated Cloud Flow.
2. Select the trigger When a row is added, modified, or deleted in Microsoft Dataverse (Dynamics 365).

• • This ensures the flow runs whenever a new client record is added

3. Add a Condition to confirm the record includes a valid email:

1. • Left value: Email
   • Condition: is not equal to
   • Right value: (leave blank)

This ensures documents are only sent when an email address exists.

Step 3: Use Power Automate to Send, Track, and Manage Documents through DocuSign

1. Add the action Create envelope using a template with recipients and tabs from the DocuSign connector.

2. Here’s what to configure in ‘Create envelope using a template with recipients and tabs’ action:

• Select your DocuSign account connection.
• Choose the DocuSign template you created earlier.
• When you click on advance options Email Subject Field will be appeared then ‘Enter a Subject’ for the Email.
• Provide an email body.
• In Customer Recipient or Signing Group Name column pass the dynamic value for name.
• In Customer Recipient Email (Leave empty if there’s a signing group) column pass dynamic value of Email.

This step prepares the document with all required details ready to be sent for eSignature.

3. Add one more DocuSign action: Send envelope.
   

This ensures that the document is sent automatically to the client without needing to log in to DocuSign manually. Once the record is created, the email is instantly delivered to the client’s email for signing.

Step 4: Track the Signing Progress

4. DocuSign provides full visibility into every step of the signing journey.

You can track when the document is:

• • Sent to the recipient
  • Opened and viewed
  • Signed and completed

These details are recorded in the Agreement History within DocuSign, helping you maintain a complete audit trail for each client agreement.

Step 5: Finalize and Notify

Client Perspective:

5. The client receives an email with a secure link to review the document.
   
   

6. Upon clicking Review Document, the client is redirected to DocuSign to view and sign.

7. Once the document is opened, the client can review the details and complete the signing process with just a few clicks.

Administrator Perspective:

8. After the client signs the document, an automatic confirmation email is sent to adminstrator.

The Benefits of Automation

Manual document signing is now a thing of the past. With this automation, clients can securely review and sign agreements from any device, while your team tracks every step from sent to signed in real time. All records are stored safely, ensuring a faster, smarter, and more reliable signing experience.

Key Benefits:

• Efficiency: Faster turnaround with minimal manual work
• Accuracy: No missing details or signatures
• Transparency: Real-time tracking of document progress
• Professionalism: A modern, seamless experience for clients.

Frequently Asked Questions

1. Can I automate DocuSign directly from Dynamics 365?
   Yes. By connecting Dynamics 365 with Power Automate and using the DocuSign connector, you can automatically send documents when a record is created or updated.
2. How do I track if a document is signed in DocuSign?
   DocuSign provides envelope status updates (sent, viewed, signed) that can be captured in Power Automate and stored in Dynamics 365.
3. Do I need a premium Power Automate license for DocuSign?
   Yes. The DocuSign connector requires a premium Power Automate plan or per-flow license.
4. Can the signed documents be stored automatically?
   Yes. You can extend the same flow to upload the signed documents into SharePoint, OneDrive, or a specific Dynamics 365 record.

Conclusion

Integrating Power Automate with DocuSign transforms your signing workflow into a fully automated, end-to-end process. Each time a new client record is created, the system automatically sends the configured document for signature, tracks its progress, and securely saves the signed copy all without manual effort. This seamless process ensures smoother operations and an enhanced client experience.

The post How to Automate Document Signing with DocuSign in Power Automate first appeared on Microsoft Dynamics 365 CRM Tips and Tricks.

Introduction

Often, we encounter challenges in mission-critical flows that drive key departmental or enterprise-wide processes, including bulk operations. While these flows are essential for business continuity, they can face disruptions in multiple ways, such as ownership changes due to role transitions or user deactivation, or exhausting daily Power Platform flow request limits. For example, if a user owns multiple high-volume flows, such as those processing thousands of Dataverse records or sending bulk emails, every run consumes requests from their personal allocation. Once his limit is reached, all his flows start throttling, causing delays or failures across multiple processes. The risk is even higher for flows using premium connectors, such as Microsoft 365 Outlook, which can fail if the owner’s license is revoked or reassigned. The complexity further increases in environments that use DevOps pipelines to deploy flows across Development, Test, and Production, where manual ownership or connection adjustments can introduce delays and errors.

Take, for example, a flow triggered by a lead status update that sends personalized follow-up emails using the premium Outlook connector. Such a flow keeps leads engaged through timely communication, but if it breaks due to an ownership change, a revoked license, or exceeding the owner’s daily flow request limit, engagement rates can drop by up to 50%. Sales reps are then forced to follow up manually, leading to inefficiency, delays, and lost opportunities.

In this blog, we’ll explore how service principal-owned flows can stabilize automation in Dynamics 365 CRM, share a practical implementation for resolving lead nurturing disruptions, and demonstrate how they can prevent flow request limit bottlenecks in enterprise-wide or high-volume processes.

Understanding Service Principal Application Users

Before going ahead, let’s know a little bit more about Service Principal Application Users. A service principal is a non-human identity in Microsoft Entra ID that represents an application or service. In Power Platform, a service principal application user owns and manages Power Automate flows, ensuring stability for mission-critical processes like lead nurturing in Dynamics 365 Sales.

Unlike human users, it’s unaffected by role changes, requires no user license, and operates under its own independent flow request limits. When paired with a Power Automate Per-flow license for premium connectors (e.g., Microsoft 365 Outlook), it can support up to 250,000 requests daily in Dataverse, ensuring that high-volume flows don’t consume a human owner’s quota. This separation of capacity makes service principals ideal for reliable, cost-efficient automation in D365 CRM.

Licensing Requirements for Service Principal-Owned Flows

Service principal-owned flows in Dynamics 365 Sales and Dataverse require specific licensing to ensure uninterrupted operation, especially for flows like the lead nurturing automation using the premium Microsoft 365 Outlook connector.

• General Licensing: Service principals, as non-interactive users, cannot use user licenses. Flows with premium connectors, such as Outlook for sending personalized emails, require a Power Automate Per-flow license, which supports up to 250,000 requests per 24 hours.
• Dynamics 365 Context: In environments with Dynamics 365 Sales and Dataverse, flows using standard or premium connectors (e.g., updating lead scores) get 500,000 base requests plus 5,000 per User Subscription License (USL), up to 10M with Tenant pool enabled, often exempting additional licensing.
• Power Apps/Power Automate Context: For flows triggered by Power Apps or standalone Power Automate, standard connectors get 25,000 base requests, while premium connectors need a Per-flow license for up to 250,000 requests. Verify licensing in the Power Platform admin center.

Implementation Steps for Service Principal-Owned Flows

To address ownership challenges and licensing dependencies, implementing a service principal-owned flow provides a stable, resilient solution. Here’s how to set up such a flow in Power Automate, for example, lead nurturing in our scenario.

Prerequisites

• Create a service principal application user in Microsoft Entra ID (Azure Portal > Microsoft Entra ID > App registrations > New registration) and link it in the Power Platform admin center (Settings > Users + permissions > Application user > New App User).

1. Share Required Connectors:

For non-solution flows, share the Dataverse connector (for lead updates) and Microsoft 365 Outlook connector (for emails) with the service principal:

Navigate to Connections, select your connector, and add the service principal as a shared user.

For solution flows, connection sharing is not required, as connections are embedded.

2. Assign Flow Ownership:

• In the Power Automate portal, navigate to “My Flows” from the side menu.
• Open your flow and go to the Details section, click Edit, and set the Service Principal Application User as the owner.

Note: Service principal users can’t be co-owners of a flow. The service principal application user does not appear in the Owners edit dialog.

3. Turn On the Flow:

• Activate the flow in the Power Automate portal to start automated lead nurturing.
• Monitor initial runs to confirm emails are sent and lead scores are updated correctly.

By operating under a non-human identity, this flow is immune to disruptions caused by user deactivation or license revocation, ensuring consistent performance for any enterprise-wide application or bulk operations.

Best Practice: For flows that are enterprise-wide, high-volume, or bulk operations, assign them to the service principal from the start. This ensures that both ownership stability and flow request limit capacity are addressed proactively, avoiding later disruptions.

Conclusion

Service principal-owned flows offer a reliable approach for stabilizing automation across Dataverse environments, including Dynamics 365 Sales and other critical enterprise-wide applications. As demonstrated in the lead nurturing example, they eliminate failures tied to ownership changes, avoid per-user flow request limit exhaustion, simplify licensing, and ensure consistent execution of the flow.

With service principal ownership and proper licensing in place, organizations can confidently automate business-critical processes, boosting lead conversion, preserving pipeline accuracy, and maintaining continuity across sales operations, without being constrained by the daily capacity of any single user.

The post How to Use Service Principals to Stabilize Business-Critical Flows and Bypass Flow Request Limits first appeared on Microsoft Dynamics 365 CRM Tips and Tricks.