Over the past few months, Copilot has become one of the most talked-about features in the Microsoft ecosystem. But one thing still confuses many people:

There are actually two different Copilot experiences available in Microsoft 365.

• Microsoft 365 Copilot – the paid add-on
• Copilot Chat – the free chat experience included with Microsoft 365

At first glance, they look almost identical. Both allow you to type prompts and get responses from AI.

However, when you try to use them in a real business scenario, especially inside CRM, the difference becomes very clear.

Recently, I experimented with both tools using a practical Dynamics 365 CRM scenario, and the results made the distinction crystal clear.

If you work in Sales, Customer Service, Consulting, or Project Delivery, this comparison will help you understand which Copilot actually makes a difference.

The Problem: AI That Can’t See Your Work

In most organizations, information about a customer is spread across multiple systems.

For example, in a typical CRM workflow you might have:

• Customer emails in Outlook
• Meeting notes from calendar events
• CRM notes and activities
• Service cases
• Tasks and follow-ups
• Internal discussions
• Documents and attachments

When you ask AI to summarize a customer opportunity or identify risks, it needs access to all of this context.

But not every Copilot has that visibility.

To understand the difference, I created a simple real-world test scenario inside CRM.

What Is the Difference Between Copilot Chat and Microsoft 365 Copilot?

Copilot Chat is a general-purpose AI assistant that works only with user-provided prompts.

Microsoft 365 Copilot, on the other hand, integrates with Microsoft Graph to access organizational data such as emails, meetings, documents, and CRM records allowing it to generate context-aware insights.

The Use Case: A Real CRM Opportunity

To test both Copilot experiences, I recreated a realistic opportunity inside CRM.

Here’s the setup:

• Account: Contoso Retail Group
• Primary Contact: Sarah Thompson
• Opportunity: Contoso POS Upgrade Project

To simulate a real project, I added different pieces of information across the system:

• Email conversations with the engineering team discussing migration constraints
• Opportunity notes describing the migration strategy and potential risks
• Meeting notes covering API readiness and dashboard activation timelines
• Tasks related to preparing proposals and scheduling pilot migrations
• A service case linked to the account about previous POS downtime

In short, this was a normal customer project scenario where information exists in many places.

The Prompt I Asked Both Copilots

Once everything was ready, I asked both copilots the exact same question:

“Summarize the Contoso POS Upgrade Opportunity using emails, notes, meeting notes, case details, and tasks. Include customer concerns, risks, and next steps.”

What Happened with Copilot Chat

When I asked Copilot Chat, the response was polite but limited.

It replied that Sorry, I don’t know that one yet, but I’m always learning.

 In simple terms, Copilot Chat had no visibility into the opportunity context.

Copilot Chat is still useful for tasks like:

• Writing content
• Brainstorming ideas
• Creating templates or plans
• Explaining general concepts

But when it comes to understanding your day-to-day work inside business systems, it simply doesn’t have access to the necessary information.

What Happened with Microsoft 365 Copilot

Next, I ran the same prompt using Microsoft 365 Copilot.

The difference was immediate.

In simple terms, Microsoft 365 Copilot understands your work context by connecting to organizational data across the Microsoft ecosystem through Microsoft Graph. This allows it to automatically gather insights from emails, meetings, documents, notes, tasks, files, and conversations within the Microsoft 365 environment. Using this connected context, Copilot was able to generate a much richer and more meaningful summary of the opportunity.

The output included insights such as:

From Emails

• Planned migration downtime window
• Deployment approach using store batches
• Customer concerns about weekend disruptions

From CRM Notes

• Engineering feedback on legacy scripts
• Risk related to unsynced transactions
• Offline billing requirements

From Meeting Notes

• API integration readiness
• Estimated dashboard activation time

From Tasks

• Preparing customer update communication
• Scheduling pilot migration
• Updating proposal documentation

From the Service Case

• Previous POS downtime incidents
• Early signs of customer frustration

The summary felt less like a chatbot response and more like something a project analyst might prepare before a stakeholder meeting.

Copilot Chat vs Microsoft 365 Copilot: Key Differences

Feature	Copilot Chat	Microsoft 365 Copilot
Access to CRM Data	No	Yes
Microsoft Graph Integration	No	Yes
Context Awareness	Primarily in‑chat only	High
Data Sources	Manual input only	Emails, meetings, CRM, tasks
Best Use Case	Writing & brainstorming	Business workflows & decision-making

Why This Matters for CRM Professionals:

CRM work rarely lives in a single record.

Important information about a customer often exists across:

• emails
• meetings
• internal discussions
• notes
• cases
• tasks

To truly understand the situation, you need to connect all those pieces together.

That’s exactly what Microsoft 365 Copilot is designed to do.

Instead of analyzing one piece of information at a time, it can combine insights from multiple sources and provide a complete picture of the situation.

Copilot Chat, on the other hand, only understands the information you manually paste into the chat window.

Final Thoughts

Copilot Chat and Microsoft 365 Copilot may look similar, but they serve very different purposes.

Copilot Chat is great for general AI assistance like writing, brainstorming, and answering questions.

Microsoft 365 Copilot, on the other hand, connects directly to your organization’s data and understands the context of your work.

For professionals working in sales, consulting, customer service, or project delivery, that difference can dramatically improve productivity.

Instead of manually gathering information from multiple systems, Microsoft 365 Copilot helps you see the full picture and act faster.

And in customer-facing roles, having that complete context can make all the difference.

FAQ: Copilot Chat vs Microsoft 365 Copilot

Q: Can Copilot Chat access Dynamics 365 CRM data?
No, Copilot Chat cannot access CRM data unless you manually provide it in the prompt.

Q: What makes Microsoft 365 Copilot different?
Microsoft 365 Copilot integrates with Microsoft Graph to access emails, meetings, documents, and CRM data, enabling context-aware insights.

Q: Is Microsoft 365 Copilot worth it for CRM users?
Yes, especially for sales, service, and consulting teams who rely on insights across multiple systems.

The post Microsoft 365 Copilot vs Copilot Chat: Key Differences for Dynamics 365 CRM Users first appeared on Microsoft Dynamics 365 CRM Tips and Tricks.

Organizations frequently receive employee requests for training programs, certifications, or skill-development courses. Traditionally, these requests go through manual review and approval processes which can delay decision making and create administrative overhead.

With Advanced Approvals in Microsoft Copilot Studio, it is possible to automate such decisions using AI. Instead of relying on human approval stages, AI can evaluate the request details and decide whether the request should be approved or rejected based on predefined criteria.

In this article, we will build a Training Request Approval System where:

• A user creates a training request record in Dataverse
• An AI approval stage evaluates the request
• The AI automatically approves or rejects the request

This implementation demonstrates how AI-driven approvals can automate business decisions without human intervention.

Prerequisites

Before starting, ensure the following are available:

• Access to Microsoft Copilot Studio
• A Power Platform environment with Dataverse enabled
• Basic knowledge of Dataverse tables and Copilot Studio agent flows

Solution Overview

The workflow implemented in this article follows a simple structure.

1. Employee submits a training request
2. The request is stored in Dataverse
3. AI evaluates the request
4. The system updates the approval status

This removes the need for manual manager approvals and allows faster decision making.

Step 1: Create a Dataverse Table for Training Requests

First, create a Dataverse table that will store the training requests.

Example table: Training Requests

Suggested columns:

Column Name	Type
Employee Name	Text
Course Name	Text
Training Provider	Text
Cost	Currency
Training Date	Date
Approval Status	Choice (Pending, Approved, Rejected)

This table will be used by the AI flow to read and update request details.

Step 2: Create an Agent Flow in Copilot Studio

Navigate to Copilot Studio → Agent Flows and create a new flow.

Agent flows allow you to automate processes using AI and actions connected to data sources like Dataverse.

In this implementation, the agent flow will:

• Retrieve the training request
• Evaluate the request using AI
• Update the request status.

Agent Flow creation screen in Copilot Studio

Step 3: Configure the Multistage Approval Step

Add the Run a multistage approval action in the flow.

This feature allows AI to evaluate requests based on specific instructions.

Since this implementation focuses on AI-only approval, no manual stages are added.

The flow will only contain the Evaluate Request AI stage.

Run a multistage approval (preview) configuration screen

Step 4: Define AI Evaluation Instructions

Inside the Evaluate Request step, define clear instructions for the AI model so it knows how to evaluate the request.

Example instructions:

Evaluate the employee training request and decide whether it should be Approved or Rejected.

APPROVE the request if ALL of the following are true :

– The trainingCost <= 1000.00

– trainingStartDate is after the date the course is purchased (i.e. coursePurchaseDate)

– The request contains all required details including employeeName, courseName, trainingCost, and trainingStartDate.

REJECT the request if any of the above are false.

Note: Here trainingCost, trainingStartDate, employeeName, courseName, coursePurchaseDate are dynamic fields as shown below in the image

These instructions guide the AI model to consistently evaluate each training request.

AI instruction configuration inside the Evaluate Request stage

Step 5: Update the Dataverse Record

After the AI evaluates the request, configure the next step in the flow to update the Dataverse record.

Based on the AI decision:

• If Approved → Update Approval Status to Approved
• If Rejected → Update Approval Status to Rejected

This ensures the final decision is stored directly in Dataverse.

Dataverse Update Row action in the flow

Testing the AI Approval Process

Once the flow is configured:

1. Create a new training request record
2. Trigger the agent flow
3. Observe the AI evaluation
4. Verify that the Approval Status updates automatically

This demonstrates how AI can independently make approval decisions based on defined rules.

Dataverse Update Row action flow when all conditions are met / true

Dataverse Update Row action flow when all conditions are not met / false

Example training request record before and after AI evaluation

Challenges You May Encounter

While implementing AI approvals in Copilot Studio, you may encounter some configuration challenges.

1.Writing Effective AI Instructions

The AI model relies heavily on the instructions provided. If instructions are vague, the decision may be inconsistent.

To avoid this:

• Clearly define approval and rejection conditions
• Keep the logic simple and structured.

2.Mapping Dataverse Fields

Incorrect field mapping between the agent flow and Dataverse may prevent the AI from reading request data correctly.

Always verify:

• Column names
• Data types
• Input parameters passed to the AI stage.

3.Understanding AI Decision Outputs

The AI stage returns structured output which must be correctly interpreted when updating Dataverse records. Improper condition checks may cause incorrect status updates.

4.Preview Feature Limitations

The Multistage Approval feature is currently in preview, so some UI elements or configurations may change over time.

Benefits of AI-Driven Approvals

Implementing AI-based approvals provides several advantages:

• Faster decision making
• Reduced dependency on manual approvals
• Scalable automation
• Consistent evaluation logic
• Seamless integration with Dataverse

Conclusion

Advanced approvals in Microsoft Copilot Studio open new possibilities for automating decision-based workflows. In this example, we built a Training Request Approval System where AI evaluates each request and determines whether it should be approved or rejected.

FAQs: Automating Training Request Approvals with AI in Microsoft Copilot Studio

• What is AI-driven approval in Microsoft Copilot Studio?
  AI-driven approval in Microsoft Copilot Studio automates the decision-making process for requests, such as employee training requests. Instead of waiting for human manager approval, AI evaluates the request based on predefined rules and updates the approval status automatically in Dataverse.
• How does the training request approval system work?
  The system works in a few steps:

1. An employee submits a training request in Dataverse.
2. The AI agent flow in Copilot Studio retrieves the request.
3. The AI evaluates the request against predefined approval criteria.
4. The AI updates the request status as Approved or Rejected.

• What are the prerequisites for setting up AI approval in Copilot Studio?
  To implement AI-based training approvals, you need:

1. Access to Microsoft Copilot Studio.
2. A Power Platform environment with Dataverse enabled.
3. Basic knowledge of Dataverse tables and Copilot Studio agent flows.

• Can AI completely replace human approval for training requests?
  Yes, AI can handle approval entirely if the evaluation logic is clearly defined. AI ensures faster, consistent, and scalable approvals, reducing administrative overhead. However, organizations can still add manual review stages if needed.

The post Automating Training Request Approvals Using AI in Microsoft Copilot Studio first appeared on Microsoft Dynamics 365 CRM Tips and Tricks.

Today’s businesses rarely operate within a single application. Applications such as Sales Hub, which manage leads, opportunities, accounts and revenue to help sales teams close deals faster. On the other hand, Customer Service helps handle cases, tickets and customer support interactions to deliver faster issue resolution. Field Service is used to schedule technicians, manage work orders and track on-site services efficiently. Marketing Automates campaigns, emails, and customer journeys to generate and nurture leads. Project Operations plans, tracks, and bills projects by combining project management, resources, and financials in one system.

Here, each application works well individually, but together they often feel disconnected. Users need to switch between platforms, copy information manually, and spend more time navigating systems than actually solving problems. Even with AI copilots available, the experience doesn’t always improve because most copilots are still limited to one application at a time.

Key Takeaways

• Traditional copilots are limited to single applications
• MCP Server enables structured, cross-system interactions
• Copilot agents can execute workflows across Business Central, Dataverse, and SharePoint
• Reduces manual effort and system switching significantly

Limitations of Traditional Copilots:

Traditional copilots are helpful assistants, but their scope is short. They can answer questions, summarize information or perform small actions within the app they belong to. However, they struggle when there are tasks that require answers from multiple systems.

As a result, users still do most of the work manually. The copilot informs but it doesn’t truly execute.

What is MCP Server in Copilot? (Simple Explanation)

MCP (Model Context Protocol) Server provides a structured way for copilots to interact with multiple systems using predefined tools instead of direct API calls.

Copilot with MCP Server:

To make Copilot genuinely useful, it needs accessibility across multiple systems. This is where Microsoft Copilot, combined with the Model Context Protocol (MCP) comes into the picture.

MCP Server acts as a bridge between Copilot agents and enterprise tools. Instead of directly accessing databases or API’s in an unstructured way, the agent communicates through standardized tools exposed by the MCP server. These tools define exactly what the copilot needs to do. Whether it’s retrieving data or updating records.

MCP Server with different Systems:

With MCP Server, the copilot can interact with different platforms such as Microsoft Dynamics 365 Business Central, Microsoft Dataverse and Microsoft SharePoint.

Instead of treating each system separately, the copilot works across them as if they were one connected environment. For the user, it feels like interacting with a single intelligent assistant.

Key Criteria to Consider While Setting Up MCP:

Before building an MCP-powered agent, start with –

• Creating a Copilot agent from scratch by attaching the right tools. Each tool represents a specific capability, such as reading customer data, updating records or accessing documents.
• Clear descriptions and proper instructions ensure the agent understands how and when to use each tool. Once activated, the copilot can securely communicate with multiple systems.

Steps to Implement Copilot with MCP Server

Let us understand this by 3 real-life scenarios –

Scenario 1: Sales Deal Closure with Dynamics 365 Business Central

In this scenario, the copilot agent will check customer financial information from Business Central before closing a sales deal. It helps verify details like credit limits or financial exposure, so the user can decide whether the deal can be approved or not.

Step 1: Let us start by creating a blank Copilot agent named ‘Enterprise Unified Agent’. At this stage, the agent has no knowledge or access to any systems.

Step 2: A tool needs to be added that allows the agent to connect with ‘Microsoft Dynamics 365 Business Central’ through the MCP server.

Step 3: Inside Business Central, the MCP Server Configuration needs to be opened in order to connect Copilot with it.

Standard API’s are then exposed as tools so the copilot can access them.

After saving the configuration and refreshing the tools, they become available for the agent to use.

Step 4: Each tool needs to be provided with a clear ‘Description’ explaining its purpose. These descriptions help the copilot understand when and how each tool should be used during interactions with the user.

Step 5: Add ‘Instructions’ in the agent, which provides guidelines to the copilot on how to respond, what tasks to perform, and how to use the available tools during interactions. Once the configuration is complete, the agent can start interacting directly with Business Central data.

Step 6: Now the user needs to simply ask a question regarding sales deal closure, and the copilot retrieves the required information, such as customer details, along with the final decision as ‘Approved’ or ‘Not Approved’, without the need to manually navigate through the system.

Scenario 2: Technician Scheduling and Service Booking with Business Central and Microsoft Dataverse Server

In this scenario, the copilot helps manage service requests by checking asset details, verifying spare parts availability, and scheduling a technician. It collects issue details, date, and time, then books the service by using information from both Business Central and Dataverse.

Now we have to enhance the copilot by connecting it to multiple systems instead of just one.

Step 1: The second tool for ‘Microsoft Dynamics 365 Business Central’ needs to be configured using the same MCP setup process. This allows the agent to access additional data and perform more actions within the system.

Add ‘Description’ for the tool as per the requirement:

Step 2: An additional tool is needed to be added for ‘Microsoft Dataverse’ so the agent can retrieve records that are stored in it.

Add ‘Description’ for the tool as per the requirement:

Step 3: Add ‘Instructions’ to the agent as per the requirement:

Step 4: Now we need to make a connection between ‘Microsoft Business Central’ and ‘Microsoft Dataverse’ by entering the environment URL and enabling the data synchronization so the copilot can access updated information from both systems.

Step 5: Now we need to add Dataverse tables as knowledge sources, which will allow the Copilot to retrieve data from them whenever needed.

Necessary Tables are added as below:

Step 6: Now the user asks a question regarding ‘Technician booking’, so the copilot retrieves the required information by using both Microsoft Dataverse and Microsoft Dynamics 365 Business Central to process the request and provide the response.

Step 7: The agent interacts with the user to collect required details such as:

• Issue description
• Service date and time

As you can see above, the copilot asks for the required details like the ‘Issue & service time’, then checks the system and schedules the technician accordingly

Scenario 3: Retrieve Instructions from Documents with SharePoint

In this scenario, the copilot accesses documents stored in SharePoint to answer user questions. It reads policies, guidelines, or reference files and provides the required instructions so users can quickly find the information they need.

Step 1: To retrieve instructions, documents need to be added to Microsoft SharePoint.

Step 2: To make these documents accessible, Microsoft SharePoint needs to be added as a knowledge source for the Copilot, as shown below

We need to upload the necessary ‘Documents’ to Microsoft SharePoint as below

Step 3: ‘Descriptions’ and ‘Instructions’ need to be added to guide the agent on how and when it should use the document-based information during conversations.

Step 4: Now the user needs to ask the agent questions that require information from documents in SharePoint.

As you can see above, the copilot searches the documents and shows the required instructions step by step based on the question.

Conclusion:

By the end of these 3 scenarios, the copilot grows from a simple blank agent into a smart assistant that can connect to different systems and help complete tasks. Instead of opening multiple apps like Business Central, Dataverse, or SharePoint, users can just ask the copilot and get the information they need in one conversation. This shows how a basic copilot can gradually become a powerful tool that not only answers questions but also helps get real work done faster.

FAQs

1. What is MCP Server in Microsoft Copilot?

MCP (Model Context Protocol) Server enables Copilot to interact with multiple systems using predefined tools instead of direct API calls. It standardizes how Copilot accesses and executes actions across platforms.

2. Can Copilot work across multiple Dynamics 365 applications?

Yes. With MCP Server, Copilot can interact with Business Central, Dataverse, and SharePoint within a single workflow, enabling cross-system execution.

3. How is MCP different from traditional API integrations?

APIs require custom integration logic, while MCP exposes standardized tools with predefined schemas, making it easier for Copilot to discover and use capabilities dynamically.

4. What are MCP tools in Copilot?

MCP tools are predefined actions (like retrieving data or updating records) that Copilot can invoke. Each tool represents a specific business capability exposed by a system.

5. Is MCP Server required for building advanced Copilot agents?

For cross-system and action-oriented Copilot scenarios, MCP Server is essential as it enables structured, secure, and scalable integrations.

The post How to Build a Cross-System Copilot Agent in Dynamics 365 Using MCP Server first appeared on Microsoft Dynamics 365 CRM Tips and Tricks.

Automation testing requires interacting with different UI elements in an application. Tests may fail for several reasons such as incorrect selectors, synchronization issues, or unexpected changes in the UI. Identifying reliable UI selectors is therefore crucial when writing complex automation scripts. One of the most common causes of UI automation failures is the use of incorrect or unstable selectors.

Some common reasons why automation scripts fail include:

Targeting Incorrect Selectors

• The UI element no longer exists on the page.
• The selector matches multiple UI elements.
• The UI structure has changed after application updates.

Timing and Synchronization Issues

• Modern web applications often load content asynchronously. As a result, UI elements may appear after a delay. Tests can fail if the script attempts to interact with an element before it is available. Using proper waiting mechanisms such as explicit waits and assertions helps ensure that elements are present and in the correct state before interacting with them.

Playwright Inspector

Debugging tools such as the Playwright Inspector allow to pause test execution and visually inspect the web page during test runs. This makes it easier to identify locator issues and understand how the test interacts with the application.

The Playwright Inspector works as a debugging interface that opens when Playwright tests are executed in debug mode. It provides several useful capabilities:

• Pause and step through test execution
• Inspect elements on the page
• Validate selectors used in the test
• Generate reliable locators
• Observe browser actions in real time

Because Playwright interacts with a real browser, it allows to observe actual browser behavior. This helps in verifying that the application performs as expected during automation. With the Inspector, you can:

• Watch the browser perform each action
• Verify navigation, clicks, and form submissions
• Confirm that the application behaves as expected
• Step through the test line by line
• Ensure waits and assertions are placed correctly

In previous blog we have already explored how Playwright can be used for Dynamics 365 automation testing wherein we have simply created contact record using Typescript code.

Using TypeScript with Complex Selectors:

Let’s extend the same use case. While creating a Contact record in Dynamics 365 CRM, we will now work with more complex UI elements such as lookup fields and option set fields. At the same time, we will use the Playwright Inspector for live debugging.

To perform the debugging process you can add a page.pause() method to your test. This way you will see the GUI page appears for “Playwright Inspector” while running the test.

By following the same steps provided in previous blog you can complete the Playwright setup (if not already) and here is the upgraded version of typescript code with more complex selectors and debugging step.

Typescript:

Create tests/contact.spec.ts:

Note: You can refer below code await page.pause () is added explicitly.

import { test, expect, Page } from '@playwright/test';

import { populate } from 'dotenv';

import fs from 'fs';

import path from 'path';

 

// --- AUTOMATIC VIDEO SAVER (FIXED) ---

test.afterEach(async ({ page }, testInfo) => {

const video = page.video(); // get video BEFORE closing

await page.close();

 

if (video) {

const videoPath = await video.path();

const timestamp = new Date().toISOString().replace(/[:.]/g, '-');

const newName = `${testInfo.title.replace(/\s+/g, '_')}_${timestamp}.webm`;

const historyFolder = 'video-history';

 

if (!fs.existsSync(historyFolder)) {

fs.mkdirSync(historyFolder);

}

 

const newPath = path.join(historyFolder, newName);

await fs.promises.copyFile(videoPath, newPath);

 

console.log(` Video saved to: ${newPath}`);

}

});

 

test('Create New Contact in D365', async ({ page }) => {

// Debugging step

await page.pause()

test.setTimeout(120000);

 

const appId = process.env.APP_ID!;

const orgUrl = process.env.CRM_URL!;

 

// 1. Navigate directly to Contacts grid, pause command use for debugging

 

await page.goto(`${orgUrl}/main.aspx?appid=${appId}&pagetype=entitylist&etn=contact`);

await page.waitForLoadState('domcontentloaded');

 

// 2. Click New (robust selector)

const newButton = page.locator("(//span[contains(.,'New')])[1]");

await expect(newButton).toBeVisible({ timeout: 30000 });

await newButton.click();

 

// 3. Wait for form to load (First Name field)

const firstName = page.locator('[data-id*="firstname"] input');

await expect(firstName).toBeVisible({ timeout: 30000 });

 

// 4. Fill mandatory fields

await firstName.fill('Test');

await page.locator('[data-id*="lastname"] input').fill('Bot');

await page.locator('[data-id*="jobtitle"] input').fill('Dev');

await page

.locator('[data-id*="emailaddress1"] input')

.fill('auto34@example.com');

 

const parentAccountInput = page.locator('[data-id*="parentcustomerid"] input');

 

// A. Click the field to activate it

await parentAccountInput.click();

 

// B. Type the search value

await parentAccountInput.fill('test');

 

// C. Wait for the dropdown results to appear and click the correct one

// We look for a list item (role=option or li) containing the text 'test'

const lookupResult = page.getByRole('option', { name: /test/i }).first();

 

// Ensure the result is actually visible before clicking to avoid flakes

const resultList = page.locator('ul[aria-label*="Lookup results"]');

await resultList.waitFor({ state: 'visible', timeout: 10000 });

 

// 4. Select the item from within that list

// We use locator('li') to match the list item specifically, ensuring we don't click other UI elements

const correctOption = resultList.locator('li').filter({ hasText: /test/i }).first();

 

await correctOption.waitFor({ state: 'visible', timeout: 5000 });

await correctOption.click();

 

// 5. Validation (Optional but recommended)

// Ensure the input field now contains the text (meaning selection stuck)

//await expect(parentAccountInput).toHaveValue(/test/i);

 

// --- PREFERRED METHOD OF CONTACT FIX ---

 

// 1. Target the wrapper, NOT the input (which is invisible)

// We use .first() just in case the selector matches the label and the field

const contactMethodDropdown = page.locator('[data-id*="preferredcontactmethodcode"]').first();

 

// 2. Wait for the wrapper to be visible

await contactMethodDropdown.waitFor({ state: 'visible', timeout: 10000 });

 

// 3. Click to expand the list

await contactMethodDropdown.click();

 

// 4. Select 'Email' from the expanded list

const emailOption = page.getByRole('option', { name: 'Email' });

 

// Wait for the dropdown animation

await emailOption.waitFor({ state: 'visible', timeout: 5000 });

await emailOption.click();

 

// 5. Save (button role, not menuitem)

const saveButton = page.locator("(//span[contains(.,'Save')])[1]");

await expect(saveButton).toBeVisible({ timeout: 30000 });

await saveButton.click();

 

});

Run the test:

Run the above typescript file using below command

npx playwright test contact.spec.ts –headed

As you have add a page.pause() it run your tests in debug mode. You can play, pause or step through each action of your test using the toolbar at the top of the Inspector.

Step Over:

Clicking the “Step Over” button in the Playwright Inspector will run the test step by step and will show a LIVE execution on browser as shown:You can see the current action highlighted in the test code, and matching elements highlighted in the browser window.Pick Locator:

While debugging, you might need to choose a more resilient locator. You can do this by clicking on the Pick Locator button and hovering over any element in the browser window. While hovering over an element you will see the code needed to locate this element highlighted below which then you can copy it into your code.Record feature:

You can click on “Record” button and “Start Recording” the other web element with user interactions corresponding typescript code will be recorded/generated in background through recording feature.When started recording you will be able to locate the element start filling in data and can view generated code.The new Playwright Inspector window opens up where the recording code can be viewed and can be copied in the existing code.You can explore more about Playwright locators here and may need to tweak little bit in recorded script and start using the same in existing code.

Conclusion:

Using Playwright Inspector makes debugging UI automation much easier by allowing inspect elements and execute tests step by step. This helps identify unstable selectors and improves the reliability of automation scripts. This leads to more stable tests and a smoother automation development process.

FAQs

What are the common causes of UI automation test failures in Microsoft Dynamics 365?

UI automation tests in Microsoft Dynamics 365 commonly fail due to:

• Unstable or incorrect UI selectors
• Frequent UI updates in Dynamics 365
• Asynchronous loading of elements
• Timing and synchronization issues
  Using reliable locators and proper wait strategies helps reduce failures.

What is UI automation testing in Microsoft Dynamics 365 CRM?

UI automation testing in Microsoft Dynamics 365 involves simulating user interactions (like form entry, navigation, and record creation) to validate that the CRM application behaves correctly. Tools like Playwright help automate these workflows efficiently.

How does Playwright help with Dynamics 365 automation testing?

Playwright enables:

• Cross-browser automation
• Reliable element handling with auto-waiting
• Powerful locator strategies
• Built-in debugging tools like Playwright Inspector

This makes it highly effective for automating complex Dynamics 365 applications.

Is it possible to automate end-to-end workflows in Microsoft Dynamics 365 using Playwright?

Yes, Playwright supports full end-to-end automation in Dynamics 365, including navigation, form submissions, lookups, and validations. With proper waits and selectors, entire business workflows can be reliably automated.

How can you verify form submission in Dynamics 365 automation?

Form submission can be verified by checking confirmation messages, updated field values, or successful navigation. Assertions ensure that the action has completed as expected.

How do you handle timing issues in Dynamics 365 automation?

Timing issues are handled using Playwright’s auto-waiting along with explicit waits like waitFor() and assertions. This ensures elements are fully loaded and ready before interaction, reducing test failures.

What is the advantage of using role-based selectors in Playwright?

Role-based selectors improve reliability by targeting elements based on accessibility roles rather than structure. This makes tests more stable, especially in dynamic applications like Dynamics 365.

The post How to Use Playwright Inspector for Faster Test Debugging in Dynamics 365 CRM first appeared on Microsoft Dynamics 365 CRM Tips and Tricks.

If you’ve been working with AI in your business processes lately, you’ve probably run into a really frustrating roadblock: the gap between the chatty text an AI wants to give you and the structured data your automation actually needs.

Let’s say you’re building a Power Automate flow to pull details out of customer emails. You want the person’s name, the priority, and the category. Ideally, you want to get back something clean like this:

JSON:

{

"customer_name": "Sarah Johnson",

"priority": "High",

"issue_category": "Billing"

}

Instead, the AI usually gives out a whole paragraph:

“The customer, Sarah Johnson, appears to have a high-priority concern related to billing. It would be advisable to route this to the finance team for further assistance.”

That’s great if a human is reading it. But for an automated flow? It’s a nightmare. You end up trying to write expressions using ‘split()’ or regular expressions just to grab the values you want, and if the AI rephrases even slightly on the next run, those expressions break. The core issue is straightforward: AI produces conversational text, but automated systems require structured, predictable data.

Microsoft’s Power Platform has a fix for this inside the AI Builder Prompt action. Whether you are using Power Automate or Copilot Studio, you can just tell the AI to hand you back perfectly formatted JSON instead of a paragraph. And the best part? That JSON maps straight into your Dynamics 365 fields, your flow conditions, or your Copilot variables. No messy parsing needed.

Understanding AI Builder Prompts

The Prompt tool can be accessed via the Power Apps maker portal, under AI Builder in Prompts. It allows users to define a custom AI instruction with optional dynamic input variables, and the generated response can be consumed in Power Automate or in Copilot Studio. By default, the output is plain text, but switching the output format to JSON enables the AI to return a structured object that downstream actions consume directly.

As a general guideline: use text output when communicating with a user, and JSON output when communicating with a system.

Setting Up a Prompt with JSON Output:

Navigate to Power Apps maker portal, under AI Builder in Prompts select the Build your own Prompt.

When writing the prompt, three elements are essential: a clear task definition, the JSON schema (field names, data types, allowed values), and explicit output constraints (return only the JSON, no extra text or formatting). Define dynamic inputs by clicking on Input, for example, an ‘EmailBody’ variable to hold customer email text passed from a flow.

In the configuration panel, change the Output format from Text to JSON. Use the built-in Test feature to validate the response structure.

Once tested, integrate it into Power Automate via the “Run a prompt” action, or into Copilot Studio as a Prompt Tool directly or use it within a topic.

Automated Email Categorization with Power Automate

Support teams get flooded with emails every single day. Usually, a human has to sit there, read each one, figure out the priority, guess the customer’s mood, and write a summary.

By combining the Prompt tool with JSON output, you can put this whole categorization process on autopilot. Here is roughly how it flows:

– An Email Arrives: A distressed customer sends an email regarding a critical payment failure on their account.

– The Prompt Analyzes: Your flow triggers immediately, grabs that email text, and ships it over to the AI Builder Prompt you built.

– Clean Data is Structured: The AI reads it, understands the context, and hands you back a neat JSON block.

– Parsed for Automation: Using the “Parse JSON” action in Power Automate, the structured data is instantly converted into dynamic content. You can now use these variables anywhere in your flow to route the email to the right team, trigger an urgent alert, or seamlessly create a record in Dataverse.

Conclusion

Switching AI Builder Prompts to JSON output is a simple but powerful enhancement for building production-ready automation.

While text responses are useful for human interaction, JSON output provides the structure required for reliable system integration.

This approach:

• Eliminates fragile parsing logic
• Ensures consistent AI responses
• Enables direct mapping to business systems

For any solution involving Power Automate, Copilot Studio, or Dynamics 365, using JSON output is one of the most impactful improvements you can make with minimal effort.

FAQs

What is JSON output in AI Builder Prompts?

JSON output is a structured response format in AI Builder Prompts that returns data as key-value pairs instead of conversational text, making it easier for automation systems to process.

 Can JSON output integrate with Dynamics 365?

Yes, structured JSON fields can map directly into Dynamics 365 entities and records without additional transformation.

 Can JSON output integrate with Dynamics 365?

Yes, structured JSON fields can map directly into Dynamics 365 entities and records without additional transformation.

What problems does JSON output solve in AI automation?

It eliminates inconsistent AI responses, removes the need for regex or string parsing, and ensures stable automation workflows.

How do I enable JSON output in Power Apps AI Builder Prompts?

In the Power Apps maker portal, go to AI Builder → Prompts, create or edit a prompt, and change the output format from Text to JSON in the configuration panel.

The post How to Use JSON Output in AI Builder Prompts for Structured Automation first appeared on Microsoft Dynamics 365 CRM Tips and Tricks.

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 the rapidly evolving landscape of sales automation, staying ahead means leveraging the latest AI capabilities. The Sales Qualification Agent is a significant advancement in Microsoft Dynamics 365 Sales, designed to revolutionize lead qualification processes.

This advanced AI agent functions as an autonomous member of the sales team. It is capable of qualifying leads by directly engaging with potential customers, gathering critical information, and seamlessly handing off qualified leads to human sellers when specific criteria are met.

This guide provides a comprehensive technical walk-through for configuring and deploying the Sales Qualification Agent, covering capabilities from basic research to autonomous customer engagement.

Prerequisites and Infrastructure Setup

Before configuring the agent, the underlying environment must be prepared to support secure data access and automation.

App Registration and Application User Configuration

To enable the agent to interact securely with Dataverse, an application must be registered in Microsoft Entra ID (formerly Azure Active Directory), and a corresponding application user must be created in Dynamics 365.

Please refer to the official Microsoft documentation for these standard configuration steps:

• Step 1: Application Registration: Register an application with the Microsoft identity platform
• Step 2: Application User Creation: Manage application users in the Power Platform admin center

Ensure the Application User is assigned the necessary security roles before proceeding.

Configuring the Sales Qualification Agent

Access the Sales Hub application and navigate to the Copilot for Sales or Sales IQ settings area (location may vary based on version).

Step 1: Enable the Sales Qualification Feature

Locate and enable the “Sales qualification” preview feature to activate the agent’s capabilities.

Step 2: Configure Automation Levels

The agent’s level of autonomy can be configured to match organizational requirements and infrastructure readiness.

Two distinct operating modes are available:

1. Research-only (Demonstrated Mode):

• Functionality: The agent analyzes leads and generates insights, drafting suggested emails for sellers to review and send manually.
• Prerequisites: Standard App Registration and Application User.
• Use Case: Ideal for organizations evaluating AI capabilities prior to implementing fully autonomous external communication.

2. Research and engage:
   • Functionality: The agent operates autonomously, performing lead research and sending emails directly to engage with customers without human intervention.

Additional Technical Requirements:

• Shared Mailbox: A shared mailbox must be provisioned in the Microsoft 365 Admin Center to serve as the agent’s sending address.
• Server-Side Synchronization: The shared mailbox must be enabled for Server-Side Synchronization within Dynamics 365 to facilitate automated email transmission.

Use Case: High-volume sales environments requiring immediate, automated lead qualification and follow-up.

Quick Note: This guide utilizes the Research-only mode to demonstrate core analytical capabilities without requiring immediate Exchange infrastructure modifications.

Step 3: Configure Agent Profile

Define the agent’s persona, including its display name and tone of voice. This configuration ensures the agent’s communication aligns with corporate branding standards.

Step 4: Add Knowledge Sources    

To function effectively, the agent requires context about the organization. Input comprehensive company details to ensure accurate representation during interactions.

Step 5: Define Products and Value Propositions

The agent must be trained on the product portfolio. By accurately defining products and their specific value propositions, the agent is equipped to address customer inquiries and articulate benefits effectively.

Configuring Agent Logic: Criteria and Routing

This section covers the configuration of the agent’s decision-making logic, defining target audiences and handoff triggers.

Selection Criteria

Establish precise criteria to define which leads the agent should process. Filters can be applied based on attributes such as lead source, industry, or geography to ensure resource optimization.

Handoff Criteria

Define the logic for determining when a lead is considered “qualified.” Copilot can assist in generating these natural language rules. A typical rule might be: “Hand off when the customer expresses clear purchase intent or requests a quotation.”

Assignment Rules

Configure routing rules to determine lead ownership post-qualification. These rules ensure that qualified leads are programmatically assigned to the appropriate seller or sales team.

Reviewing Performance and Handoff

Upon completion of the setup, the agent requires a brief initialization period to begin processing valid leads.

Monitoring Performance and Check Result

The Agent Insights dashboard provides real-time metrics on agent performance. Key analytics include the volume of processed leads, qualification rates, and conversation efficiency, allowing for data-driven optimization of the agent’s configuration.

To track the effectiveness of the qualification process, the “Leads handed over by AI Agent” view offers a consolidated list of leads successfully transferred to human sellers. This view enables supervisors to monitor lead volume per seller and ensure smooth transitions.

Conclusion

The Sales Qualification Agent represents a paradigm shift in automated lead management. By delegating initial research and qualification tasks to AI, organizations can enable their sales professionals to focus exclusively on high-value activities, such as closing deals and nurturing qualified relationships.

FAQs: Sales Qualification Agent in Dynamics 365

1. What is the Sales Qualification Agent in Dynamics 365?

The Sales Qualification Agent is an AI-powered feature in Microsoft Dynamics 365 Sales that autonomously qualifies leads, engages with potential customers, and hands off qualified leads to human sellers, streamlining the sales process and saving time for sales teams.

2. How does the Sales Qualification Agent improve lead management?

By automating lead research, initial outreach, and qualification, the agent ensures faster lead response times, reduces manual effort, and helps sales professionals focus on high-value activities like closing deals and nurturing relationships.

3. Can the Sales Qualification Agent send emails directly to leads?

Yes. In the Research and Engage mode, the agent can send emails autonomously using a shared mailbox configured in Dynamics 365, while in Research-only mode, it drafts suggested emails for sellers to review and send manually.

4. What are the prerequisites for configuring the Sales Qualification Agent?

Before setup, you need:

An application registered in Microsoft Entra ID (formerly Azure AD)

A corresponding application user in Dynamics 365 Sales

Proper security roles assigned to the application user

Optional: A shared mailbox for automated email sending

5. How do I define which leads the agent should qualify?

The agent uses selection criteria based on attributes like lead source, industry, geography, or custom rules you configure. You can also set handoff criteria to determine when a lead is considered qualified.

The post How the Sales Qualification Agent Transforms Lead Management in Dynamics 365 first appeared on Microsoft Dynamics 365 CRM Tips and Tricks.

In many Dynamics 365 Sales implementations, sales users need a simple and intuitive way to preview a quote, generate a PDF, and share it with customers. Traditionally, this requirement is handled using Word templates, which often feel rigid, require backend configuration, and do not provide a smooth preview experience for users.

Microsoft has introduced PDF generation and PDF preview capabilities in Canvas apps, making it possible to convert Canvas app screens or containers into PDF files and preview them directly within the app. These capabilities open new possibilities for creating user-friendly, preview-first document generation experiences in D365 Sales.

In this blog, we demonstrate how to build a Canvas app that allows users to view quotes, preview quote details as a PDF, and prepare the PDF for sharing, all using native Power Apps functionality.

How This Works (High-Level Overview)

This approach uses a Canvas app embedded in D365 Sales to display quote data. A specific container holding the quote layout is converted into a PDF using the PDF() function. The generated PDF is stored in a variable and passed to the PDF Viewer control, allowing users to preview the document before sharing or processing it further.

App Design Overview

To keep the user experience simple and intuitive, the app is designed with two screens.

Screen 1: Active Quotes

The first screen displays active quotes in a gallery, as shown below.

This screen acts as the entry point for the user and allows quick selection of a quote.

When a user selects a quote:

• The selected quote is stored in a variable
• The app navigates to the quote preview screen

This approach keeps quote selection fast and avoids unnecessary navigation between screens.

Screen 2: Quote Details and Quote Preview

The second screen is designed to display quote details and a PDF preview side by side.

On this screen, I have used two containers:

• One container to display the quote details
• Another container to preview how the quote will appear in the PDF Viewer

To display the PDF in the PDF Viewer, the following approach is used:

Generating the PDF

The PDF() function is used to generate a PDF from the quote details container.
The generated PDF is stored in a variable (MyPdf).

This ensures that the same layout used to display quote details is reused for PDF generation.

Previewing the PDF

The MyPdf variable is then passed to the PDF Viewer control, allowing users to preview exactly how the PDF will look before it is shared.

This provides a true “what you see is what you get” experience for the user.

Below is how the page layout looks with the quote details on one side and the PDF preview on the other.

 

Important Note on Experimental Features

At the time of writing, both the PDF () function and the PDF Viewer control are marked as Experimental features in Power Apps.

Benefits of This Approach

• Preview-first user experience
• No dependency on Word templates
• Flexible and easily customizable layouts
• Consistent PDF output
• Simple integration with Power Automate for further processing

Real-World Use Cases

This pattern can be applied across multiple D365 Sales and business scenarios, including:

• Quote generation and sharing
• Invoice previews
• Order confirmations
• Service reports
• Custom sales documents

The same reusable layout approach ensures consistency across documents while keeping the user experience simple.

FAQs

Can Canvas apps generate PDFs in D365 Sales?
Yes. Canvas apps support the PDF() function, which allows screens or containers to be converted into PDF files that can be previewed or shared.

Do I need Word templates to generate PDFs in D365 Sales?
No. This approach removes the dependency on Word templates by generating PDFs directly from Canvas app layouts.

Can users preview PDFs before sharing them?
Yes. The PDF Viewer control allows users to preview the generated PDF inside the Canvas app before sharing.

Can this be integrated with Power Automate?
Yes. The generated PDF can be easily passed to Power Automate for emailing, storage, or further processing.

Conclusion:

By combining Canvas apps with the PDF() function and PDF Viewer control, it is now possible to create lightweight and flexible document generation experiences directly within D365 Sales.

This approach allows users to preview, generate, and share quote PDFs using a single reusable layout, improving usability and reducing dependency on backend templates.

The same pattern can be extended to other scenarios such as invoices, orders, service reports, or any use case where formatted documents are required.

The post Generating and Sharing Screen in PDFs from D365 Sales Using Canvas Apps first appeared on Microsoft Dynamics 365 CRM Tips and Tricks.

Earlier, the Task Details pane in Project Operations was standard and not customizable at admin level. When users clicked the info icon present next to a task, a fixed task pane from Project showed only predefined fields. Organizations could not add custom fields or modify the layout, so users often had to navigate away from the task grid to view or update additional task details.

Now, with the latest update, the task pane is customizable. Using this feature, we can customize tasks of a project within the Task Pane itself. This allows users to view and update all relevant task information directly from the task pane, improving efficiency while still keeping the option to access the original standard view if needed.

In this blog, let us explore how to Customize Task Pane in Project Operations.

• To enable theCustomize Task Pane feature in Project Operations, navigate to the Parameters entity present in the Settings
• Click on the Feature Control button on the ribbon bar, as shown below.

• After enabling Customize Task Pane feature, navigate to Projects area under Projects group click on Projects

Note: Choose Existing Project or create a New Project.

• Let us create a project with all the required details, save it and then navigate to the Tasks tab

• Add the tasks required to complete your project. Click on any task’s ⓘ icon to view its details in the new Task Side Pane.

• Now, let us navigate to Power Apps to customize the Task Side Pane. This customization allows users to view and update task details directly from the Task Grid, eliminating the need to open separate pages or navigate away from their current screen.
• As a result, users can manage tasks more efficiently within a single, streamlined interface.

 Steps to customize the Task Pane:

1. Navigate to Power Apps and click on Tables as below –

2. Search Project Task form and click on it.

3. In Data experiences select Forms & click on Task details

4. Customize the Task details form according to your requirements.

Note: You can customize the task pane whenever you want in Task details and publish it according to your requirements.

Note:  A Resource field is added in Task details form for customization.

5. Click on Save and Publish button to apply the changes.

6. Navigate to Project, Click on Tasks tab and click on any Task’s ⓘ icon to view Task details in new Task Side Pane.

Note: Resource field added in Task details form is visible in Task Pane.

Conclusion:

This approach allows us to customize the Task Details form so users can view and update additional task information directly in the Task Side Pane, without navigating away from the task grid.

The post How to Customize the Task Pane in Project Operations first appeared on Microsoft Dynamics 365 CRM Tips and Tricks.

Dynamics 365 Customer Insights – Journeys is one of the most preferred modules offered by Microsoft, which provides a flexible platform that enables organizations to engage their audience across every stage of the customer journey.

It empowers businesses to create personalized, timely, and meaningful interactions based on customer behavior and preferences. As we all know, understanding your customers is not a one-time activity; it is a continuous journey that evolves with every interaction. Targeting the right audience to perform any marketing activity is the key to success.

When running marketing activities in Customer Insights – Journeys, the most important question to answer is:

“Who exactly should receive this message or journey?”

This is where Segments play a key role.

What Are Segments in Customer Insights – Journeys?

Segments in Customer Insights – Journeys allow you to group Contacts or Leads based on a defined set of attributes or behaviors. These segments act as the foundation for targeting audiences in real-time journeys, emails, and other marketing engagements.

Using segments, you can:

• Filter Contacts or Leads using specific conditions
• Target audiences based on demographic or behavioral data
• Ensure messages reach the most relevant audience

Segments help transform generic marketing campaigns into highly targeted and strategic journeys.

Types of Segments in Customer Insights – Journeys

There are two types of segments available in Customer Insights – Journeys:

1. Automatic Refresh (Dynamic Segment)
2. Static Snapshot (Static Segment)

In earlier versions of the Marketing app, users could choose the segment type directly while clicking the New Segment button. In the current Real-time Journeys experience, this behavior has changed.

Now, you must:

1. Create the segment first
2. Define the segment type later from the Settings panel

Where to Find Segments in Customer Insights – Journeys

To access segments:

• Go to Customer Insights – Journeys
• Navigate to Real-time journeys
• Select Audience → Segments

At the segment record level, you will notice a Type field that indicates whether the segment is configured as a Static Snapshot or an Automatic Refresh.

How to Create a Segment in the New Experience

When you click New Segment, you are no longer prompted to choose between Static or Dynamic upfront. Instead, the segment is created first, and its behavior is defined later.

During creation, you have two options:

1. Using Query Assist (Copilot)

Query Assist allows Copilot AI to help generate segment logic.

• Start typing in the Query Assist box
• Select a predefined prompt such as “Contacts who opened an email”
• Click Create

You can either:

• Click Use to apply the suggested query
• Or click Create manually to skip AI assistance

Once selected, Copilot helps build the initial query structure based on the chosen prompt.

During creation, you have two options:

1. Using Query Assist (Copilot)

Query Assist allows Copilot AI to help generate segment logic.

• Start typing in the Query Assist box
• Select a predefined prompt such as “Contacts who opened an email”
• Click Create

You can either:

• Click Use to apply the suggested query
• Or click Create manually to skip AI assistance

Once selected, Copilot helps build the initial query structure based on the chosen prompt.

You can find more details in this doc for understanding the building segment with “Query Assist”.

2. Creating a Segment Manually

If you prefer full control:

• Click Create manually, or
• Leave the Query Assist box empty and click Create

This opens the Segment Builder, where you can define your logic from scratch.

Building Segment Logic Using the Segment Builder

Inside the Segment Builder, you can define segment criteria using:

• Attribute-based conditions (e.g., Industry, Country, Job Title)
• Behavioral conditions (e.g., email opens, form submissions)
• Include or Exclude specific Leads or Contacts

You can explicitly include or exclude records. Even if a record does not meet the defined conditions, it will always be included or excluded if specified manually.

If you include or exclude any lead explicitly, then even if it has not met the pre-defined condition, it will always be filtered and will be included or excluded from the segment member list.

When you open Segment Builder, you can start creating a new group by clicking on the desired options (either Attribute or Behavioral). if required, you can Include or Exclude a particular audience as well.

Refer screenshots below:

Example Use Case: Targeting Manufacturing Leads from India

Let’s consider a practical example.

Use case:
Target Leads from the Manufacturing sector located in India.

Segment conditions:

• Industry equals Manufacturing Services
• Country/Region equals India

You can create an Attribute group and define these conditions accordingly. Once the logic is complete, save the segment.

Before activating it, you can preview the audience size.

Estimating Segment Size Before Activation

Before marking a segment as Ready to use, you can:

• Click Estimate to preview the expected number of segment members
• Review the estimated member count to validate your logic

This helps ensure your targeting criteria are accurate before using the segment in a journey.

The members count can be previewed from here:

Segment Settings: Static Snapshot vs Automatic Refresh

The Settings panel is where the segment type is defined.

By default, all newly created segments are set to Automatic Refresh.

Let us consider one of the Dynamic Segment graphs. As you can see in the graph below, the segment size has been updated (increased) over the duration.

If there is a use case where you want to create the Segment as Static, then explicitly you have to set it as “Static Snapshot” option as shown below:

In “Static Snapshot,” the simple segment size will not be updated dynamically, and it is of one-time use.

Let us consider one of the Static Segment graphs, as you can see in the graph below, the segment size has remained standstill over the duration, as it was a one-time activity.

Key Differences: Static Snapshot vs Automatic Refresh

Feature	Static Snapshot	Automatic Refresh
Membership updates	No	Yes
Audience type	Fixed	Dynamic
Best suited for	One-time campaigns	Ongoing journeys
Data refresh	One-time	Continuous
Real-time targeting	Not supported	Supported

 

FAQs

What Is Automatic Refresh (Dynamic Segment)?

In Automatic Refresh, the segment membership updates dynamically.

This means:

• New Contacts or Leads that meet the criteria are automatically added
• Records that no longer meet the criteria are removed
• The segment size changes continuously over time

Dynamic segments are ideal for:

• Ongoing marketing journeys
• Real-time audience targeting
• Long-running nurture campaigns

You can observe these changes visually through segment growth graphs, where the member count increases or decreases over time.

What Is Static Snapshot (Static Segment)?

In Static Snapshot, the segment captures audience members at a specific point in time.

This means:

• Segment membership does not update after activation
• The audience remains fixed
• It is typically used for one-time activities

Static Snapshot segments are best suited for:

• One-time email campaigns
• Event invitations
• Compliance or audit-based targeting

Segment graphs for Static Snapshot segments show a flat line, indicating no change in membership over time.

When Should You Use Each Segment Type?

• Use Automatic Refresh when your audience changes frequently and journeys run continuously.
• Use Static Snapshot when you need a fixed audience for a specific moment or campaign.

Choosing the right segment type ensures accurate targeting and optimal journey performance.

Conclusion

Segments play a critical role in successfully targeting audiences within Customer Insights – Journeys. Whether you are grouping customers based on demographic attributes or behavioral interactions, segments allow you to make your marketing more strategic and data-driven.

Automatic Refresh segments are ideal for real-time, evolving journeys, while Static Snapshot segments are best suited for one-time or fixed audience scenarios. Understanding the difference between these two options helps you design more effective journeys and deliver the right message to the right audience at the right time.

The post Static or Dynamic Segments? A Complete Guide for Customer Insights – Journeys first appeared on Microsoft Dynamics 365 CRM Tips and Tricks.