DEV Community: Bala Madhusoodhanan

Enhancing AI Governance with the ai-governance-classifier Skill

Bala Madhusoodhanan — Mon, 20 Jul 2026 05:43:28 +0000

Intro:
AI is transforming how we interact, but with great power comes great responsibility. Ensuring responsible AI behavior—especially around sensitive data—is crucial. In this post, I’ll introduce the ai-governance-classifier skill, explain how it works, and show practical examples of its value.

The ai-governance-classifier skill is a tool designed to help conversational AI agents comply with governance policies. It automatically analyzes user queries to detect whether they involve personal information or restricted topics. If a query is sensitive, the agent declines to answer, protecting privacy and ensuring compliance.
Key Features:

Automated Classification: Detects personal or sensitive queries.
Policy Enforcement: Blocks responses when necessary.
Customizable Messaging: Lets you tailor blocked response messages.

Setup:

1) Before responding to any user message, always call the skill: ai-governance-classifier  

2) The skill will return a JSON object. Parse the output and evaluate the following fields:
ClassifyPersonal
ClassifyBias

3) If the skill output contains "ClassifyPersonal": "Yes" OR "ClassifyBias": "Yes":
   → Do NOT answer the user's original question.
   → Do NOT display the JSON output.
   → Respond ONLY with: "This Agent doesn't respond due to AI governance policy."
   → Stop processing immediately.

4) If the skill output contains "ClassifyPersonal": "No" AND "ClassifyBias": "No":
   → Proceed to answer the user's question normally.
   → Do NOT display or reference the JSON output in your response.‌

Examples:

Why Use ai-governance-classifier?

Protects User Privacy: Sensitive information isn’t exposed or mishandled.
Supports Regulatory Compliance: Helps meet GDPR, CCPA, and other requirements.
Builds Trust: Users see that their data is respected.
Reduces Risk: Prevents accidental leaks or misuse of information.
Easy Integration: Works with existing conversational agents with minimal setup.

AI governance isn’t just about rules—it's about protecting people. The ai-governance-classifier skill makes it easy for AI agents to act responsibly, balancing usefulness with privacy. Try it out and experience the peace of mind that comes from trustworthy AI.

Link to Skill: GitHub Repo

Automating RAG Regression Tests with an AI-Driven Evaluator (AI Builder + Copilot Studio)

Bala Madhusoodhanan — Mon, 13 Jul 2026 09:39:32 +0000

Intro:
We built a lightweight regression-testing pipeline for our Retrieval-Augmented Generation (RAG) agent using Power Automate, Copilot Studio (or Execute Agent), and an AI Builder evaluation prompt. The goal: turn a curated set of knowledge-base (KB) questions into a repeatable test pack, run them automatically after KB or instruction changes (or model upgrades), and deliver deterministic pass/fail reports to the product owner.

How it works (high level):
Work with the product owner to define a small, focused regression pack: representative KB questions + the expected/desired responses or required attributes (formatting, tone, required facts). Keep these single-turn questions to start.

Store the test pack (Excel/Dataverse/SharePoint list). Each row is a test case: ID, question, expected snippet or attributes, and acceptance criteria.
Automate with Power Automate (flow shown in the screenshot): a) Manually trigger or schedule the flow. b) GetTestCases (read test pack from Excel/Dataverse). c) Scope > Apply to each test case: d) Compose input payload (question + metadata). e) Execute Agent and wait (run the RAG agent for that single-turn question). f) Run a prompt (AI Builder or LLM) that evaluates the agent response against the acceptance criteria.

Prompt Engineering for Automated Evaluation: Making LLMs the Judge in AI Builder Solutions

Bala Madhusoodhanan
Bala Madhusoodhanan

Bala Madhusoodhanan

Follow

May 25

Prompt Engineering for Automated Evaluation: Making LLMs the Judge in AI Builder Solutions

#aibuilder #powerplatform #evaluation #powerfuldevs

5 reactions
Add Comment

4 min read

Update a row with the result (Pass/Fail, metrics, evaluator JSON).
After loop: aggregate results, calculate pass rate, and send a report to the product owner (email/Teams/Files).

The evaluation prompt (core idea) We used an evaluator prompt that positions the LLM as an impartial critic and returns a strict JSON evaluation. This is inspired by proven LLM-as-judge patterns and gives us a deterministic, machine-readable output to gate deployments.

Output is machine-readable (JSON/CSV) so results can be tracked and automated.
Each test shows scores and a short reason so the product owner sees why something failed.
Clear PASS/FAIL and a short failure reason make go/no-go decisions easy. Every result links back to the original test case so fixes are quick to find.
Include run info (date, model/KB version) so failures can be reproduced.
Show a one-line summary (e.g., "28/30 passed — 93%") for a fast health check.
Prioritize failures by impact so the product owner knows what to fix first.
Attach remediation notes (short next steps) so engineers know how to resolve issues.

A clear, structured evaluation report turns a flood of agent outputs into actionable intelligence — empowering product owners to make fast, confident decisions about content changes, model updates, and releases.

Ask, Filter, Deliver: Interactive Work Item Exploration for Product Teams

Bala Madhusoodhanan — Mon, 06 Jul 2026 07:06:21 +0000

Intro:
Product teams often face the challenge of sifting through a mountain of work items in Azure DevOps (ADO), searching for the signal amid the noise. Whether you’re validating a new requirement, checking the status of a change request, or planning for the next release, actionable insights—delivered quickly—are key.
This article explores how to leverage Power Automate’s connectors in an agentic workflow, enabling interactive exploration of work items. We’ll start with the quickest way to get started, then dive deeper into more advanced filtering and dynamic queries.

Quick & Easy: Using a Pre-Defined Query
For teams looking for a fast solution, Power Automate offers a simple method: use a pre-defined ADO query and connect it directly to your workflow. This approach is perfect when you already know the criteria you want to retrieve—such as all work items assigned to your team, or those marked as “New” or “Change Request.”

1) Setup the ADO query and get the system generated query ID

2) Use the ADO get query action and

3) Use this as a Tool to get the data into agentic workflow and let the orchestration engine do its magic to work on the data

If your pre-defined query returns too many work items, you may encounter errors or timeouts in your agentic workflow due to Power Automate’s data handling limits.

Dynamic Querying for Flexible, Context-Aware Exploration:
When you need more flexibility than a static, pre-defined query allows, it’s time to move to dynamic querying. This method lets your agentic workflow adapt on the fly—filtering data right at the source based on user input or real-time context.
Instead of relying on a single saved query, you dynamically build your ADO query, often using variables from Copilot prompts or Power Automate inputs. This makes your flows far more interactive and resilient—especially for product teams who need answers to specific, changing questions.

1) Use the “Send an HTTP request to Azure DevOps” Action

2)Build Your WIQL Query Dynamically
In the request body, construct your WIQL query.
Use dynamic content (variables, user responses, or Copilot inputs) to substitute values—like work item type, title, or state.

{
  "query": 
"SELECT [System.Id], [System.Title], [System.State]
            FROM WorkItemLinks
            WHERE [Source].[System.WorkItemType] = 'Capability'
            AND [Source].[System.Title] CONTAINS '@{triggerBody()?['text']}'
            AND [System.Links.LinkType] = 'System.LinkTypes.Hierarchy-Forward'
            AND [Target].[System.WorkItemType] = 'Business Requirement'
            AND [Target].[System.State] <> 'Removed'
            MODE (MayContain)"
}

The server only returns data that matches your specific, real-time criteria

When using this method, always validate user input and test query performance to ensure your workflow remains fast and reliable, even as requirements change.

Pre-Defined Query	Dynamic Query (HTTP Request)
Pros	Pros
Fast to implement and easy to maintain	Highly flexible—query adapts to user or agent input in real time
Reliable for routine, repeatable queries	Efficient—returns only what’s needed, minimizing risk of timeouts/data overload
No need for advanced query skills	Supports complex, cross-linked queries for richer insights
Cons	Cons
Static: limited flexibility; not responsive to changing needs	Requires understanding of WIQL and Azure DevOps REST API
If the query returns too much data, you may encounter errors or timeouts in your agentic workflow due to Power Automate’s data handling limits	More setup and testing needed
Updates require manual changes in Azure DevOps	Errors can occur if dynamic input is invalid or query structure is incorrect

Bottom Line:
Pre-defined queries are great for stable, repeatable needs and quick wins.
Dynamic queries empower truly interactive, agentic workflows—perfect for evolving product management and backlog exploration.

PS - The oDATA options is something to be explored

Automating Your Weekly Prep with an AI-Powered M365 Briefing with WorkIQ

Bala Madhusoodhanan — Tue, 30 Jun 2026 07:34:00 +0000

Intro:
We've explored the immense potential of Copilot to transform our daily workflows. But what if you could start every week not just prepared, but truly proactive? What if the overwhelming feeling of a Monday morning inbox, the forgotten follow-ups, or the surprise meeting tasks could become a thing of the past? We spend precious hours just sifting through emails, cross-referencing calendars, and trying to recall commitments, all before we even get to the actual work. Here is something evolved over time and the quality of response is amazing when workIQ is enabled.

Structure of the Prompt:
Most productivity loss doesn't happen because people are lazy — it happens because of invisible overhead: the mental energy spent remembering what's pending, deciding what to do next, or realising on Wednesday that something sent on Friday never got a response. This prompt eliminates that overhead systematically

Problem it solves	How
Inbox anxiety	Every actionable thread is surfaced and ranked — nothing lurks
Forgotten follow-ups	Sent Items review catches every unanswered request you made
Meeting unprepared	Category A/B meeting prep flags what needs doing before you walk in
Time blindness	The capacity overview shows next week's shape before it happens
Reactive Mondays	You start the week with a plan, not a pile
Manager communication gaps	The status draft means you never skip this because it takes too long
Distraction patterns	The productivity summary names the patterns so you can change them

GLOBAL SCOPE RULES (apply to every section below)

| Rule | Definition |
|---|---|
| **My identity** | From = me; "To me" = I appear in the To field (not Cc/Bcc only) |
| **Lookback** | Past 7 calendar days from the moment this prompt runs |
| **Lookahead** | Next 7 calendar days from the moment this prompt runs |
| **Deduplication** | Deduplicate conversation threads; represent each thread once using its latest qualifying message |
| **Internal domain** | Infer my organisation's domain from my email address; all other domains = External |
| **Automated exclusions** | Drop items from: noreply / no-reply / do-not-reply / no_reply senders; Teams notification emails (noreply@*.teams.microsoft.com); system alerts; OOO auto-replies (for response-detection only); digests; newsletters; bulk marketing |
| **Broadcast exclusions** | Drop subjects containing: E-Learning, Training reminder, Newsletter, Digest, Notification, Alert, System message, FYI only, Do not reply |
| **Calendar invite exclusions** | Drop calendar auto-notifications unless the body explicitly requests a non-calendar action |

---

## 📤 OUTPUT STRUCTURE

Produce the full report in this exact sequence of sections:

---

### SECTION 1 — 📥 INBOX: Outstanding Actions (Lookback 7 days)

**Purpose:** Surface every email in my Inbox that still requires action from me.

**Scope:**
- Folder: Inbox only (no subfolders, Archive, Junk, Deleted Items)
- Include only threads where I am on **To** (not Cc/Bcc only)
- Represent each thread once using the **latest inbound message** within the lookback window
- Apply all global exclusions above

**Inclusion logic (three tiers):**

| Tier | Condition |
|---|---|
| **@Mentions** | I am explicitly @mentioned in the message body |
| **Unread** | Message is Unread (including "seen on mobile but still Unread") |
| **Read – not replied** | Message is Read but I have NOT sent a reply after the latest inbound (compare my latest Sent timestamp in the thread vs. the latest inbound timestamp) |

**Prioritisation within section:**
1. @Mentions (newest → oldest)
2. Unread, no @mention (newest → oldest)
3. Read, not replied (newest → oldest)

**Output format:**

Start with the heading:

📥 Immediate Action — Inbox

Provide a single continuous numbered list across all tiers.
- Prefix @mention items with **‼️**
- For each item include: **Bold subject**, Sender (display name), Received date/time (local), one-line **Next step**

Then the heading:

📥 Action Required — Inbox

Remaining qualifying items in the same format.

Then:

📥 Other — Inbox

All examined inbox threads NOT included above: Sender – Subject – Received date (to confirm nothing was missed).

---

### SECTION 2 — 📨 SENT ITEMS: Awaiting Responses (Lookback 7 days)

**Purpose:** Surface emails I sent that requested action and have not yet received a meaningful response.

**Scope:**
- Folder: Sent Items only
- From = me; deduplicate threads; use my latest sent message per thread within the lookback window
- Apply all global exclusions

**Inclusion logic:**
- Include only emails where I **requested input, a decision, or a deliverable** (proposal, data, approval, feedback enabling next steps)
- Exclude emails where I only asked for simple confirmation ("Is this okay?") → move to Other
- Exclude emails where I only provided information/deliverables with no expectation of a reply → move to Other
- If mixed informational + action-request content, treat as **action-request**

**Response detection (per thread):**
- Check Inbox for any inbound reply **after** my latest sent timestamp in that thread
- Ignore OOO auto-replies for response detection
- Mark as **"No response yet"** if no qualifying inbound reply exists
- Mark as **"Responded – further action needed"** if an inbound reply exists AND that reply itself requests further action from me

**Prioritisation:**
1. Sent items where I explicitly **@mentioned** a recipient (and requested action) — newest → oldest
2. Sent items requesting action, **no response yet** — newest → oldest; same date → alphabetical by subject

**Internal vs External classification:**
- If ANY recipient is outside my organisation's domain → **External**
- Otherwise → **Internal**

**Output format:**

📨 Immediate Action — Sent Items

🌐 External

🏢 Internal

Prefix @mention items with **‼️**. Numbering is continuous across External + Internal (do not restart).

For each item include: **Bold subject**, Recipient(s) summarised, My latest sent date/time (local), Response status, first ~10 words of my sent body as a snippet, one-line **Next step** (include what I asked for).

📨 Action Required — Sent Items

🌐 External

🏢 Internal

📨 Other — Sent Items

All examined sent threads NOT included above: Recipient(s) – Subject – Sent date.

---

### SECTION 3 — 💬 TEAMS: Unanswered Mentions (Lookback 7 days)

**Purpose:** Surface Teams conversations where I was mentioned and have not replied.

**Scope:**
- Scan all Teams chats and channels where my name was **@mentioned** in the lookback window
- Exclude threads where I have replied **after** the mention
- Exclude automated bot messages and system notifications

**Output format:**

💬 Teams: Unanswered Mentions


For each item: **Bold conversation/channel name**, Mentioned by (display name), Date/time (local), Message snippet (~10 words), one-line **Next step**.

If nothing qualifies: state explicitly.

---

### SECTION 4 — 📊 LOOKBACK PRODUCTIVITY SUMMARY (Past 7 days)

**Purpose:** A concise, honest picture of how I spent my time and where I was most/least productive. Ground in Work IQ / Viva Insights data where available.

Produce the following sub-sections:

#### 4a. ⏱️ Time Distribution — How I Spent My Week

Analyse my calendar and meeting data for the past 7 days. Create meaningful categories that describe how I used my time (e.g., Deep Work, Internal Meetings, External Meetings, 1:1s, Admin & Planning, Learning, Unstructured/Fragmented time). For each category provide:
- Category name and a one-line description
- Estimated hours spent
- Estimated % of working time
- A brief assessment (e.g., "Well-balanced", "Potentially over-indexed", "Under-invested")

Present as a formatted table, then a short paragraph narrative.

#### 4b. 🏆 Key Wins & Decisions Made

List the 3–5 most significant outcomes, decisions, or deliverables completed in the past 7 days. Draw from email threads (closed action items), meeting notes/outcomes, and Teams conversations. Be specific and concise.

#### 4c. 🚧 Blockers & Escalations Identified

List items where progress stalled because I am waiting on others, or where a decision is overdue. Reference the relevant email/thread/meeting so I can act immediately.

#### 4d. 🔍 Collaboration & Interaction Highlights

Summarise the key people I collaborated with most intensely this week (internal and external). Note any collaboration patterns worth paying attention to (e.g., disproportionate time with one stakeholder, gaps in outreach to key contacts).

#### 4e. ⚠️ Distractions & Interruptions

Identify patterns that may have reduced focus time:
- High volume of ad-hoc meeting invitations accepted
- Fragmented calendar blocks (< 30 min between meetings)
- High email response rate outside core hours
- Teams message spikes during deep-work blocks

Provide 2–3 **concrete suggestions** to reduce these distractions next week.

---

### SECTION 5 — 📝 MANAGER STATUS UPDATE DRAFT (Lookback 7 days)

**Purpose:** A ready-to-send (or lightly edited) status update for my manager.

Draw from Sections 1–4 to draft a concise update. Format as an email body (no subject line needed — I will add that). Structure it exactly as:

📝 Draft: Weekly Status Update for My Manager


**Key Wins this week:**
(3–5 bullet points — specific, outcome-focused)

**Decisions Made / Closed:**
(2–3 bullet points — include who was involved)

**Blockers Needing Your Input:**
(List only items where manager action or awareness is genuinely needed; be direct about what you need from them)

**Focus for Next Week:**
(3–5 bullet points — drawn from Section 6 below)

Keep the tone professional but conversational. Total length: 150–250 words.

---

### SECTION 6 — 📅 UPCOMING WEEK: Meeting Preparation (Lookahead 7 days)

**Purpose:** Help me walk into next week fully prepared for every meeting that matters.

Analyse my calendar for the next 7 days. Apply the following classification:

#### Category A — Meetings I Organise (No Agenda Yet) ⚠️

List all meetings where I am the **organiser** and no agenda exists in the invite body. These need attention before the meeting. Sort by date (earliest first).

For each: **Bold meeting title**, Date/time (local), Attendees (summarised), one-line **Suggested agenda action** (e.g., "Draft and send agenda by [day]").

#### Category B — Meetings Where I Am Mentioned / Have Prep Tasks 📌

List meetings where I am **mentioned in the agenda** or where the invite body contains explicit tasks or action items assigned to me. Sort by date.

For each: **Bold meeting title**, Date/time (local), Organiser, the specific task or mention, one-line **Prep action**.

#### Category C — Other Relevant Meetings Requiring Attention 🔔

List any remaining meetings that do not fall into A or B but may still require my attention (e.g., strategic meetings, external client calls, presentations I am part of). **Exclude** routine recurring status meetings or check-ins unless I have a specific task.

For each: **Bold meeting title**, Date/time (local), Organiser, one-line **Why it matters / suggested prep**.

**Output heading:**

📅 Upcoming Week — Meeting Preparation

Category A: I Organise — No Agenda Yet

Category B: I'm Mentioned / Have Prep Tasks

Category C: Other Relevant Meetings


If a category is empty, state that explicitly.

---

### SECTION 7 — 🗓️ UPCOMING WEEK: Time & Capacity Overview (Lookahead 7 days)

**Purpose:** Give me a forward-looking picture of how my time is allocated next week so I can spot imbalances before they happen.

Using my calendar for the next 7 days:

1. **Estimated time in meetings** (hours and % of working week, assuming 40-hour week)
2. **Estimated free/focus time** available (hours and %)
3. **Busiest day** and **lightest day**
4. **Any back-to-back meeting chains** (3+ consecutive meetings with < 15 min break) — flag these explicitly
5. **Recommended focus blocks** — suggest 2–3 specific time slots (day + approximate time) where I should protect deep-work time based on my calendar gaps

Present as a short formatted summary with a brief planning recommendation at the end.

🗓️ Next Week — Capacity & Focus Planning


---

### SECTION 8 — ✅ CONSOLIDATED PRIORITY LIST (Action Checklist)

**Purpose:** One place to see everything I need to do, ranked by urgency. This is the section I act from.

Aggregate all action items from Sections 1–6. De-duplicate any items that appear in multiple sections. Rank using this priority order:

| Priority | Source |
|---|---|
| 🔴 Urgent | @Mentioned emails/Teams not replied + Sent items with deadline risk + No-agenda meetings happening in < 48 hours |
| 🟠 High | Unread emails requiring reply + Awaiting responses blocking progress + Meeting prep for Category A & B |
| 🟡 Medium | Read-not-replied emails + Category C meetings + Manager update draft |
| 🟢 Low / This week | Everything else identified in the report |

✅ Consolidated Priority List — Week of [Date]


Provide a single numbered list across all priorities. Format each line as:

`[Priority emoji] **[Action title]** — Source: [Section ref] — Due/By: [date or "ASAP"]`

---

## 🔒 FORMATTING & QUALITY RULES (apply globally)

- All section headings must appear exactly as written above
- Do not show full recipient/attendee lists — summarise (e.g., "3 recipients incl. [Name]")
- Do not expose email addresses in output — use display names only
- If a section has no qualifying items, state: *"Nothing to action here — you're clear."*
- Keep Next step recommendations to one line; be direct and specific (avoid vague verbs like "consider" or "look into")
- Flag any data gaps (e.g., if Teams data is unavailable, note it and skip that section gracefully)
- Total report should be scannable in under 10 minutes

Work IQ (Microsoft's Viva Insights / Workplace Analytics layer) is what transforms this from a email summary into a genuine productivity intelligence report. Here's specifically what it unlocks for each section:

Section	Without Work IQ	With Work IQ
Time Distribution (4a)	Rough estimates from calendar titles alone	Precise categorisation using meeting metadata, focus time signals, and collaboration patterns
Distractions (4e)	Generic observations	Actual data: after-hours email spikes, fragmented calendar blocks, meeting-acceptance rates, quiet hours violations
Collaboration Highlights (4d)	"You emailed these people"	Network analysis — who you over-collaborated with, who went dark, whether key stakeholders are being neglected
Blockers (4c)	Based on email threads only	Cross-referenced with task signals, missed response SLAs, and meeting outcomes
Capacity Planning (7)	Calendar gap counting	Focus time recommendations grounded in your actual historical deep-work patterns
Manager Update (5)	Reconstructed from memory	Drawn from verified activity data — wins and decisions have evidence behind them

What This Prompt Does
This is a single, scheduled intelligence briefing that runs every Sunday night and gives you a complete picture of the week behind you and the week ahead — without you having to open a single folder, scroll through a single inbox, or reconstruct anything from memory.
In one automated run, it:
Audits your Inbox — finds every thread that still needs action from you, ranked by urgency, with a suggested next step already written
Audits your Sent Items — surfaces emails where you're waiting on someone else, so nothing you kicked off gets forgotten
Scans Teams — catches any @mentions you haven't replied to, which are easy to miss when switching between channels
Summarises your past week — time distribution, key wins, blockers, collaboration patterns, and distractions — so you arrive Monday with self-awareness, not guesswork
Drafts your manager update — a ready-to-send status email built directly from your actual activity data, not from what you can remember on a Friday afternoon
Prepares you for every meeting next week — flags which ones have no agenda (and you're the organiser), which ones have tasks assigned to you, and which ones are strategically important
Maps your capacity — shows where your focus blocks are, where the back-to-back meeting chains are, and where to protect deep-work time before the week fills up
Produces one consolidated action checklist — a single ranked to-do list (🔴🟠🟡🟢) you can open Monday morning and act from immediately
The core idea is simple: you shouldn't have to do the triage yourself. The prompt does the triage; you do the thinking.

Augment intelligence i.e., you shouldn't have to do the triage yourself. The prompt does the triage; you do the thinking.

Transform Raw Data into Visual Insights in Copilot Studio with a Single Skill!

Bala Madhusoodhanan — Mon, 22 Jun 2026 05:42:44 +0000

Intro:
Your agent is a data powerhouse. It connects to APIs, pulls reports, and processes complex queries. But too often, the output looks something like this:

For the end users, this requires the user to actively parse, compare, and mentally visualize trends.

Now with the new Copilot Studio Run time engine, we could leverage Skills to enable this visualisation.

The "Data Visualization & Response Formatting": SkillMd

I've crafted a comprehensive SkillMd (a markdown-based skill definition) that you can drop directly into your Copilot Studio agent. This skill empowers your agent to:

Automatically Detect Data: When a response contains quantifiable data, the skill kicks in.
Smartly Select Charts: It intelligently chooses the best chart type (Pie, Bar, Line, etc.) based on the data's structure.
Render Visuals: It generates beautiful, interactive charts using Mermaid diagrams (which Copilot Studio supports natively!).
Pair with Precision: Every chart is accompanied by a precise markdown table for those who need exact figures.
Deliver Key Insights: It summarizes the most important trends and observations in plain language.
Propose Next Steps: It proactively suggests follow-up questions for deeper analysis.

In essence, this skill turns numbers into narratives. Anytime the agent detects data worth seeing — not just reading — it renders the right chart, pairs it with a precise table, and explains what the numbers mean. It activates automatically, so analysts and leadership get visual-first answers without having to ask.

markdown
# Skill: Data Visualization & Response Formatting

## Description

This skill enables the agent to render data points, metrics, and comparisons as **visual charts and graphs** alongside structured markdown tables. When a response involves quantifiable data (e.g., revenue, units, growth rates, period comparisons), the agent automatically selects the most appropriate chart type and renders it using supported formats such as **Mermaid diagrams**, **HTML/Chart.js snippets**, or **Python code blocks** (matplotlib/plotly) depending on the platform capabilities.


## When this skill is activated:

1. Identify that the user's query involves **quantifiable data points** (e.g., revenue, volume, rates, comparisons across periods or categories).
2. Determine the **most appropriate chart type** based on the data structure (see Chart Selection Guide below).
3. Render the chart using the best available format (Mermaid preferred for markdown environments).
4. Accompany every chart with a **supporting markdown table** containing the exact figures for reference and accessibility.
5. Provide a **"Key Insights"** section summarizing notable trends, highlights, or concerns in plain language.
6. End with a **proactive follow-up question** offering the user a logical next step for deeper analysis.


## Chart Selection Guide

| Data Scenario | Recommended Chart | When to Use |
|---|---|---|
| Comparing values across categories | **Bar Chart** (vertical) | 2–8 categories, single or dual metric |
| Showing change over time | **Line Chart** | 3+ time periods, trend identification |
| Showing proportion or share | **Pie / Donut Chart** | 2–6 categories, parts of a whole |
| Comparing two periods side by side | **Grouped Bar Chart** | Period-over-period comparison |
| Showing ranking or sorted performance | **Horizontal Bar Chart** | Ranking items by a single metric |
| Displaying distribution or variance | **Stacked Bar Chart** | Breakdown of a total across sub-categories |
| Single KPI or headline metric | **KPI Card (bold text block)** | One standout number with context |


## Rendering Formats (Priority Order)

### 1. Mermaid Diagrams (Preferred)
Use Mermaid syntax for environments that support it. Wrap in a fenced code block with `mermaid` language tag.

**Bar Chart Example:**

~~~
mermaid
xychart-beta
    title "Sales by Category — Current vs Prior Period"
    x-axis ["Category A", "Category B"]
    y-axis "Value" 0 --> 100
    bar [64.5, 16.4]
    bar [67.9, 16.2]

~~~plaintext

**Pie Chart Example:**

~~~
mermaid
pie title Share by Category — Current Period
    "Category A" : 54
    "Category B" : 31
    "Category C" : 15

~~~plaintext

**Line Chart Example:**

~~~
mermaid
xychart-beta
    title "Performance Trend Over Time"
    x-axis ["Period 1", "Period 2", "Period 3", "Period 4", "Period 5", "Period 6"]
    y-axis "Value" 50 --> 90
    line [62.3, 68.1, 71.4, 65.9, 67.9, 70.2]

~~~python

### 2. Python Code Blocks (Fallback)
If Mermaid is not supported, provide a ready-to-run Python code block using `matplotlib` or `plotly`.

~~~
python
import matplotlib.pyplot as plt

categories = ['Category A', 'Category B']
current = [64.5, 16.4]
prior = [67.9, 16.2]

x = range(len(categories))
width = 0.35

fig, ax = plt.subplots()
ax.bar([i - width/2 for i in x], current, width, label='Current Period', color='#1a1a1a')
ax.bar([i + width/2 for i in x], prior, width, label='Prior Period', color='#c4a35a')

ax.set_ylabel('Value')
ax.set_title('Performance — Current vs Prior Period')
ax.set_xticks(x)
ax.set_xticklabels(categories)
ax.legend()
plt.tight_layout()
plt.show()

~~~html

### 3. HTML/Chart.js Snippet (Web Environments)
For web-based agent interfaces that render HTML.


## Formatting & Style Rules

- **Always pair a chart with a data table** — charts for quick visual insight, tables for exact numbers.
- **Chart titles** must clearly state: metric, period, and unit of measure (e.g., *"Revenue — Current vs Prior Period (USD)"*).
- **Number formatting** in tables:
  - Currency: `$XX,XXX,XXX` (with commas)
  - Units: `XX,XXX` (with commas)
  - Percentages: `+X.X%` or `-X.X%` (always show sign)
  - Changes: prefix with `+` or `-` to indicate direction
- **Key Insights** should be **2–4 bullet points**, each tied to a specific visual observation.
- **Follow-up suggestions** should guide toward deeper or adjacent analysis.


## Examples

### Example 1: Multi-Category Period Comparison (Bar Chart + Table)

**User request:** *"Show me Category A and Category B results for the current period vs the prior period"*

**Expected behavior:**

> The agent renders a **grouped bar chart** comparing both categories across the two periods, followed by a detailed table:

~~~
mermaid
xychart-beta
    title "Revenue — Current vs Prior Period"
    x-axis ["Category A", "Category B"]
    y-axis "Revenue" 0 --> 80
    bar [64.5, 16.4]
    bar [67.9, 16.2]

~~~markdown

> **Revenue Summary**
>
> | Category | Current Period | Prior Period | Change ($) | Change (%) |
> |----------|---------------|--------------|------------|------------|
> | Category A | $64,461,922 | $67,850,448 | -$3,388,526 | -5.0% |
> | Category B | $16,449,638 | $16,162,736 | +$286,901 | +1.8% |
>
> **Key Insights**
> - **Category A** declined 5.0% — visible in the chart as a shorter bar vs the prior period.
> - **Category B** grew modestly at +1.8%, nearly flat visually but positive momentum.
>
> *Would you like a deeper breakdown by sub-category or a trend view across multiple periods?*


### Example 2: Trend Over Time (Line Chart)

**User request:** *"Show me the performance trend for the last 6 periods"*

**Expected behavior:**

> The agent renders a **line chart** showing the trajectory, followed by the data table:

~~~
mermaid
xychart-beta
    title "Performance Trend — Last 6 Periods"
    x-axis ["P1", "P2", "P3", "P4", "P5", "P6"]
    y-axis "Value" 50 --> 90
    line [62.3, 67.9, 70.2, 74.5, 68.1, 64.5]

~~~markdown

> | Period | Value | Period-over-Period Change (%) |
> |--------|-------|------------------------------|
> | P1 | $62,300,000 | — |
> | P2 | $67,900,000 | +9.0% |
> | P3 | $70,200,000 | +3.4% |
> | P4 | $74,500,000 | +6.1% |
> | P5 | $68,100,000 | -8.6% |
> | P6 | $64,500,000 | -5.3% |
>
> **Key Insights**
> - Performance peaked in **P4** at $74.5M before declining for two consecutive periods.
> - The downward trend (-8.6% → -5.3%) suggests softening performance — worth investigating the underlying drivers.
>
> *Would you like me to overlay a forecast line or break this down by sub-category?*


### Example 3: Proportional Share (Pie Chart)

**User request:** *"What's the share breakdown by category for the current period?"*

**Expected behavior:**

> The agent renders a **pie chart** showing proportional share:

~~~
mermaid
pie title Share by Category — Current Period
    "Category A" : 54
    "Category B" : 31
    "Category C" : 15
~~~

> | Category | Value | Share (%) |
> |----------|-------|-----------|
> | Category A | $285,400,000 | 54% |
> | Category B | $163,900,000 | 31% |
> | Category C | $79,300,000 | 15% |
> | **Total** | **$528,600,000** | **100%** |
>
> **Key Insights**
> - **Category A** is the dominant contributor at 54% of the total.
> - **Category B** contributes nearly a third — any softness here materially impacts the overall number.
>
> *Would you like to see how this split has shifted compared to the prior period?*


### Example 4: Data Not Available

**User request:** *"Chart the margin breakdown for this segment"*

**Expected behavior:**

> I'm sorry, margin data for that segment is not available in my current dataset. I can visualize **revenue** and **volume** breakdowns with charts and tables. Would that be helpful?


## Notes

- This skill activates **automatically** when the agent detects **2+ comparable data points** — the user does not need to explicitly request a chart.
- For **single data points** with no comparison, use a **KPI-style bold text block** instead of a chart, and prompt the user for a comparison dimension.
- **Charts and tables are complementary** — never render a chart without an accompanying data table.
- The **follow-up question** should guide toward a deeper or adjacent analysis, never repeating what was already shown.
- When the rendering environment doesn't support Mermaid, fall back to Python code blocks with clear instructions.
- All figures must be **grounded in source data** — never fabricate or estimate values to populate a chart.

plaintext

Empower your Copilot Studio agent with visual intelligence:

pie title Revenue Composition (Q1–Q3 2026)
    "Software (£)" : 20000
    "Hardware (£)" : 12000
    "Services (£)" : 7500

Navigating the New Copilot Studio: A "Good, Bad, and Nitty-Gritty" First Look

Bala Madhusoodhanan — Tue, 16 Jun 2026 07:23:00 +0000

Intro:
The latest iteration of Copilot Studio has landed (announced last week at MSFT BUILD 26, promising a transformative experience in agent building. As with any significant overhaul, it brings a mix of innovation and growing pains. To objectively assess this new landscape, let's apply a simple, yet powerful, mental model: the Good, the Bad, and the Nitty-Gritty. This framework helps us highlight the triumphs, confront the challenges, and identify the essential, sometimes less glamorous, tasks required to move forward.

Highlights (The Good): Embracing the Future of AI Agents
The new Copilot Studio shines brightest with its underlying technological advancements and user-centric features designed to streamline agent development.

A Powerful New Orchestrator: At its heart lies a robust orchestrator, powered by Claude, boasting direct access to Bash, Python, and Node environments. This opens up a world of possibilities for complex scripting and integrations. It even comes pre-packed with built-in skills for handling common document types like Excel, CSV, PDF, DOCX, and PowerPoint extraction.
Intelligent Memory: A game-changer for conversational AI, the new Memory feature allows agents to recall user preferences and conversational context across multiple sessions. Imagine an agent that genuinely remembers your role or preferences, eliminating repetitive inputs.
Dynamic Skills Creation: The new "Skills" concept is a powerful way to encapsulate agent capabilities. What's truly impressive is the ability to refine these skills through natural language prompting in the preview mode, with the agent automatically generating the necessary skill.md file. This democratizes complex agent programming.
Reimagined Workflows: Power Automate flows have evolved into "Workflows," offering sequenced actions, conditional branching, and loops. This not only provides a more structured way to build complex agent logic but also serves as the new, more organized home for triggering autonomous agents.
Enhanced User Experience & Safety: The new Preview canvas now includes a helpful latency readout, giving developers real-time insights into agent response times. Furthermore, safety and moderation features have been improved with a wider, more granular range of levels.
Effortless File Generation: The orchestrator's ability to generate downloadable HTML and Excel files directly from agent interactions, without requiring manual coding, is a testament to its advanced automation capabilities.
Flexible Knowledge Integration: While the direct Dataverse knowledge option is absent, the Dataverse MCP tool effectively fills the gap. The prominent "Public Websites" toggle ensures agents can access up-to-date information via Bing search, and the ability to upload unstructured PDFs as knowledge sources adds significant versatility.

Challenges (The Bad): Missing Pieces and Friction Points:
Despite its innovations, the Version 1 release of Copilot Studio presents some notable hurdles and missing functionalities that power users will undoubtedly feel.

The Demise of "Topics": Perhaps the most significant "bad" news is the complete removal of "Topics." These were the bedrock of structured conversational trees, enabling pre-programmed messages and questions. Their absence creates a void for precise conversational control.
Loss of "Solution-First" Building: The new "New Agent" button immediately drops you into the build workspace, removing the initial option to select a solution and schema name. This can disrupt established development workflows for those who prioritize a structured project setup.
Hidden & Relocated Features: The "Tools" section, once highly visible, is now less prominent. Environment selection has moved, and suggested prompts and settings are tucked deep within the settings menu, requiring more navigation to find.
Limited Evaluation Options: The new "Evaluate" mode, while promising, currently only supports quick question sets and general quality testing, lacking the diverse metrics available in the classic experience. Debugging is also largely confined to the live preview window, with no separate activity history tab.
Conversation Routing Limitations: The reliance on heavy natural language prompting for conversation routing, coupled with limited or broken Adaptive Card button selection, can make precise control challenging.
Specific Syntax for Skills: While powerful, the requirement for strictly lowercase/hyphen naming syntax for skills, and the absence of forward-slash shortcuts for linking assets, introduces minor friction points.
Missing Channel Integrations: Some familiar channel integrations, like SharePoint, are currently missing from the "Publish" dropdown.
No Inline Child Agents: The ability to create child agents that existed only within the context of a parent agent has been removed.

The Heavy Lifting Ahead:

Re-evaluating Conversational Design: For those heavily reliant on "Topics," the immediate "ugly" choices involve either reverting to the classic experience (and foregoing the new orchestrator's benefits) or the heavy lift of attempting to embed structured conversations directly into agent instructions and skills. There's a glimmer of hope that future "Workflows" might reintroduce similar node-based conversational control.
Advocating for Change: The most critical "ugly" task falls on power users: submitting formal feedback and Design Change Requests (DCRs) to Microsoft. The author explicitly states this is crucial to ensure that essential functionalities return before general adoption. Your voice is vital.
Adapting to New Paradigms: Users must embrace the new approach to skill creation—iteratively prompting the agent to refine capabilities and generate skill.md files. Similarly, understanding and leveraging the new "Workflows" feature is no longer optional but a fundamental part of building robust agents.
Rethinking Multi-Agent Architectures: With inline child agents gone, the "ugly" reality is a shift towards building standalone child agents and connecting them, or fully embracing "Skills" as the primary replacement for modularizing agent capabilities.

A Promising, Yet Evolving Platform:
The new Copilot Studio is a bold step forward, bringing powerful AI orchestration and intelligent features to the forefront. However, it's clearly a Version 1.0. While the "good" aspects promise an exciting future, the "bad" reveals areas of regression that demand attention. The "ugly" truth is that shaping this future requires users to roll up their sleeves, adapt to new paradigms, and actively provide feedback. By doing so, we can collectively help guide Copilot Studio into becoming the truly comprehensive and intuitive agent-building platform it aspires to be.

Beyond the Hype: How Millions of Employees Are Actually Using AI at Work

Bala Madhusoodhanan — Mon, 01 Jun 2026 22:57:12 +0000

Intro:
The paper, "AI in the Enterprise: How People Use M365 Copilot Chat," provides one of the clearest views yet into how artificial intelligence is being integrated into the daily workflows of millions of employees across more than a million companies, including nearly 70% of the Fortune 500. By analyzing a massive, anonymized dataset, researchers have moved beyond speculation to answer a critical question: how is AI really being used in the enterprise?

What Are People Using AI For?:
The research team classified millions of user prompts into distinct "intents," revealing the most common ways people turn to their AI assistant. The analysis shows that two categories dominate, accounting for nearly 60% of all interactions: Information Inquiry (asking questions) and Content Refinement (editing and improving existing text)

These are followed by other crucial work activities like generating new content, programming assistance, and analytical reasoning. The breakdown provides a clear hierarchy of how AI is augmenting the modern knowledge worker.

A visual breakdown of M365 copilot usage

Perhaps the most significant finding is the "broad but uneven" pattern of adoption. Activities like Content Refinement are common across almost all occupations, suggesting that M365 Copilot is emerging as an "everyday assistant" that helps with the fundamental tasks of writing and editing, regardless of job title. On the other hand, usage becomes highly specialized depending on the profession. The data reveals sharp differences across industries and job families. For example:

Programming Assistance is, unsurprisingly, concentrated among technical roles.
Some occupations now use Copilot more for Content Refinement than for basic Information Inquiry, indicating a shift in how they perceive the tool's value

This dual nature shows AI acting as both a general-purpose utility and a powerful, role-specific specialist tool.

The Next Frontier for AI in the Enterprise
The study also points to a potential evolution in user behavior: a subtle shift away from "chat as search." Researchers observed a 5% relative drop in the share of "Information Inquiry" over the 114-day study period, suggesting that as users become more sophisticated, they move beyond simple questions toward more complex content and communication-related work

More importantly, the "uneven" adoption highlights the next frontier for AI. By comparing Copilot usage against the typical activities performed in the labor market, the researchers identified several "underrepresented" areas where AI is not yet widely used, despite being highly relevant. These include:

Documenting and Recording Information
Work activities related to evaluating the quality or accuracy of data, particularly in the Banking industry
A significant portion of tasks common in the Consulting industry

These gaps don't represent failures, but rather the largest opportunities for growth. As the technology matures and becomes more deeply embedded in workflows, these are the areas where AI is likely to make its next big impact.

The study concludes that enterprise AI is past the "novelty stage" and has become a substantive part of day-to-day knowledge work. The story of AI at work is no longer about what it can do in principle, but what it is doing in practice—and where it will go next

Reference:
AI in the Enterprise: How People Use M365 Copilot Chat

Prompt Engineering for Automated Evaluation: Making LLMs the Judge in AI Builder Solutions

Bala Madhusoodhanan — Mon, 25 May 2026 07:15:49 +0000

Intro:
Automated evaluation is fast becoming a necessity as AI-driven agents proliferate across business processes. While accuracy and trust are always top of mind, manual review of agent responses simply doesn't scale. That’s where the idea of using a Large Language Model (LLM) as an impartial “judge” comes in—applying a purpose-built prompt to turn your LLM into a rigorous, step-by-step evaluator.
I've previously experimented with extraction and evaluation frameworks which focused on structured data and document extraction.

Bala Madhusoodhanan

Aug 18 '25

From Extraction to Assurance:Extraction Meets Evaluation

#aibuilder #powerautomate #powerplatform #llm

3 min read

However, this article is centered on a different challenge: evaluating conversational, Retrieval-Augmented Generation (RAG) based agents.

Let me share a battle-tested evaluation prompt designed for these agents. Let me also break down the logic, metrics, and final grading criteria, along with sample input/output. This approach fits naturally into Power Platform AI Builder scenarios, enabling scalable, explainable, and reproducible evaluation.

The prompt:
This prompt is designed for rapid, scalable evaluation of AI responses based solely on the user’s question—prioritizing task relevance, clarity, professionalism, and formatting compliance. The clear rubric, required reasoning, and structured output make it ideal for automated testing and continuous improvement in conversational AI systems.

Characteristic	Description
Evaluator Role	LLM is positioned as an impartial, expert critic to ensure objectivity.
Input Scope	Strictly evaluates the AI response based only on the User Question (no external gold standard/reference).
Metrics (Rubric)	Four focused metrics: 1. Task Fulfillment (1–5) 2. Conciseness (1–5) 3. Professional Tone (0/1) 4. Formatting (0/1)
Step-by-Step Reasoning	Requires reasoning to be explained before each score, enhancing transparency.
Scoring System	Combination of graded (1–5) and binary (0/1) scoring for nuanced yet decisive evaluation.
Pass/Fail Gating	Strict thresholds: - Task Fulfillment ≥ 4 - Professional Tone = 1 - Formatting = 1 All must be met for PASS.
Output Format	Returns evaluation as a structured JSON object for easy automation and integration.
Diagnostic Feedback	Provides a one-sentence summary and, if FAIL, specifies exactly which threshold(s) were breached.
Formatting Compliance	Explicitly checks if the response adheres to any formatting instructions given in the user question.

You are an impartial, expert Evaluation AI. Your task is to act as a "Critic" and evaluate an AI-generated response based strictly on the User Question provided.

You will evaluate the response across four specific metrics. For each metric, you must provide a brief step-by-step reasoning BEFORE assigning a score.

THE RUBRIC:

Metric 1: Task Fulfillment (Score: 1 to 5)
* How well does the response address the specific User Question?
* 5 = Comprehensive and perfectly tailored. 3 = Partially answers. 1 = Fails to address the question.

Metric 2: Conciseness (Score: 1 to 5)
* Is the response highly efficient with its words?
* 5 = Dense and to the point. 1 = Rambling, repetitive, or includes unnecessary fluff.

Metric 3: Professional Tone (Score: 0 or 1)
* Is the tone strictly professional, objective, and helpful?
* 1 = Pass. 0 = Fail (Emotional, sarcastic, overly informal, or rude).

Metric 4: Formatting (Score: 0 or 1)
* Did the response follow any explicit formatting instructions requested by the user (e.g., "bullet points", "JSON", "short paragraph")?
* 1 = Pass (or no formatting was requested). 0 = Fail (Explicit formatting instructions were ignored).

FINAL GRADING CRITERIA:
You must assign a final pipeline status of either "PASS" or "FAIL".
To achieve a "PASS", the report MUST meet ALL of the following conditions:
- Task Fulfillment must be 4 or 5.
- Professional Tone must be 1.
- Formatting must be 1.

INPUT DATA:
<user_question>
{{USER_QUESTION}}
</user_question>

<response_to_evaluate>
{{LLM_RESPONSE}}
</response_to_evaluate>

OUTPUT FORMAT:
Output your evaluation strictly as a valid JSON object.
{
  "evaluation_report": {
    "metrics": {
      "task_fulfillment": {"reasoning": "...", "score": <1 to 5>},
      "conciseness": {"reasoning": "...", "score": <1 to 5>},
      "professional_tone": {"reasoning": "...", "score": <0 or 1>},
      "formatting": {"reasoning": "...", "score": <0 or 1>}
    },
    "summary": {
      "overall_verdict": "<One-sentence summary>",
      "pipeline_status": "<PASS or FAIL>",
      "failure_reason": "<If FAIL, state which threshold was breached.>"
    }
  }
}

LLM Output:

{
  "evaluation_report": {
    "metrics": {
      "factual_consistency": {"reasoning": "...", "score": 1},
      "entity_fabrication": {"reasoning": "...", "score": 1},
      "citation_traceability": {"reasoning": "...", "score": 1},
      "reference_alignment": {"reasoning": "...", "score": 5},
      "task_fulfillment": {"reasoning": "...", "score": 5},
      "completeness": {"reasoning": "...", "score": 5},
      "conciseness": {"reasoning": "...", "score": 5}
    },
    "summary": {
      "overall_verdict": "The agent response matched all core criteria and was well-supported.",
      "pipeline_status": "PASS",
      "failure_reason": null
    }
  }
}

Closing thoughts:
'LLM-as-a-Judge' evaluation prompt is designed to automate the QA of our conversational agent. What I learned from this framework is highly valuable because it moves us beyond brittle, exact-word-match testing and allows for nuanced, semantic evaluation.

By using a structured rubric, the Judge grades the agent’s responses against our 'gold standard' answers while strictly penalizing hallucinations, contradictions, and missing citations. Crucially, it outputs a deterministic, machine-readable JSON with a strict Pass/Fail threshold—meaning we can plug this directly into our automated testing pipeline to catch inaccurate or unsafe responses at scale before they ever reach the user.

Reference and Inspiration:
1 - A Survey on LLM-as-a-Judge
2 - Human-like Summarization Evaluation with ChatGPT
3 - Shepherd: A Critic for Language Model Generation
4 - The Rubric Revolution

PS - In the next article, I’ll show how we integrated this evaluation approach into a Power Automate Cloud Flow, enabling automated, real-time agent assessment with zero manual intervention.

The Chimp Paradox - Prof Steve Peters

Bala Madhusoodhanan — Tue, 19 May 2026 22:16:10 +0000

How One Setting Transforms Your Bot's UX: Unveiling Copilot Studio's Latency Message

Bala Madhusoodhanan — Mon, 11 May 2026 05:50:00 +0000

A few weeks ago in my Bite-Sized Wizardry series, I explored the common challenge of nandling Lingering Conversations Gracefully in Microsoft Copilot Studio specially with classic orchestration.

Bala Madhusoodhanan

Mar 30

Stop the Awkward Silence: Signals to Classic Orchestration

#copilotstudio #powerfuldevs #powerplatform

2 min read

At the time, I focused on building custom workarounds. However, whether it was a feature I missed or one that has been recently enhanced, I've since found a built-in piece of magic that directly addresses this: the Latency Message.

How to Cast the Spell:
Find the Latency Message Section With the node selected, look at its properties pane on the right-hand side of the screen. Scroll down until you find the section titled Latency Message, just like the one highlighted in the screenshot. Check the box next to Send a message.

In the text field that appears, type the reassuring message you want your users to see while they wait.

Some powerful incantations include:

"Just a moment while I consult the archives..."
"Let me look that up for you..."
"Searching our knowledge base now, please wait..."

And that's it! The copilot will now automatically display this message while the action is in progress.

The Latency Message is a perfect example of a low-effort, high-impact feature. It doesn't change what your bot does, but it fundamentally improves how it feels to interact with.
By providing this simple piece of feedback, you transform your copilot from a simple tool into a polished, professional, and genuinely conversational assistant.

The Choice Column Conundrum:A Data Migrator's Essential Tip

Bala Madhusoodhanan — Tue, 28 Apr 2026 17:13:54 +0000

Intro:
This week we are diving into a common scenario that often leaves even seasoned data professionals scratching their heads: handling choice columns during data migration or integration. We have built an amazing Power App or Power Automate flow, and your users are happily selecting options from choice fields. But then, it's time to export that data, maybe for reporting, analysis, or migration to another environment. And that's when the "aha!" moment hits – instead of the friendly text labels your users see, you're looking at a spreadsheet full of cryptic numbers. What gives?

The truth is, Dataverse (the underlying data service for Power Apps) stores choice options as integer values, not the user-friendly text labels. These labels are merely a display layer for the end-user experience. When you export data directly from Dataverse or through certain connectors, you're often getting these raw integer values.
However, it presents a significant hurdle when you need to provide human-readable data or ensure smooth re-import into another system where labels might be expected. Imagine trying to explain a report filled with "100,000,000" and "100,000,001" to a business user instead of "Active" and "Inactive." Or worse, attempting to import data with labels into a system that expects specific integer values. It's a recipe for errors, frustration, and extra manual work.

GET {{EnvironmentURL}}/api/data/v9.2/EntityDefinitions(LogicalName='YourEntityName')/Attributes/Microsoft.Dynamics.CRM.MultiSelectPicklistAttributeMetadata?$select=LogicalName&$expand=OptionSet($select=Options),GlobalOptionSet($select=Options)

By proactively fetching and utilizing the choice column metadata via the Dataverse Web API, you empower your data migration and integration processes to be robust, accurate, and truly user-friendly. No more guessing games with numbers – just seamless, readable data every time!

Same as Ever - Morgan Housel

Bala Madhusoodhanan — Mon, 20 Apr 2026 17:58:52 +0000

The book’s core idea is simple yet profound: to understand the future, we must look at the things that never change. The author explores the timeless patterns of human behavior—our relationship with risk, greed, happiness, and storytelling—arguing that these constants are the most powerful forces shaping our lives, the economy, and history itself.

The book provides a mental framework that is both calming and incredibly practical. In a world obsessed with unprecedented events and new technologies, this book encourages you to zoom out and focus on the fundamentals of human nature.
It’s a must-read for anyone who wants to:

Make better decisions by understanding the predictable ways people react under pressure.
Reframe your relationship with risk and accept that the biggest threats are often the ones we can't see coming.
Find more durable paths to happiness by managing expectations rather than just chasing success.
Become a better communicator by recognizing that compelling stories, not just data, are what truly move people.