Skip to main content
skill CX Codex

add-sample-data · microsoft, power-pages — Claude Code skill: populate Dataverse with test records

add-sample-data — a Claude Code skill that seeds Dataverse tables with sample records so you can quickly set up test data for Power Pages demos.

MIT ★ 1,167 updated 2026-10-29

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add microsoft/power-platform-skills
/plugin install power-pages@power-platform-skills
Open on GitHub

What add-sample-data does

The skill runs in five phases: verifies PAC CLI auth and API access, discovers tables from .datamodel-manifest.json or queries them via OData, lets you pick which tables to populate and how many records per table, generates contextual sample data (realistic names for Name fields, email addresses for Email columns, dates in a sensible range), shows a preview, and inserts everything in the correct order.

Parent tables are inserted first, then child tables referencing them, so lookup IDs are available when needed. If any record insertion fails, the skill logs the error and continues with the rest — no rollbacks. You'll need both PAC CLI and Azure CLI installed; the skill uses Bash commands to verify access and Node.js scripts to call Dataverse.

What it helps with

  • seed Dataverse tables with examples for quick testing
  • prepare realistic demo data for Power Pages without manual entry
  • generate records with correct relationships between tables
  • test Power Pages workflows with your own data structure
  • initialize tables before showing demos to stakeholders

Example prompts for the agent

  • Add sample data to my Dataverse tables for testing Power Pages
  • Generate 10 records for each table in my demo environment
  • Create test records that respect the lookup relationships between Project and Task

How to install add-sample-data

1Plugin marketplace

/plugin marketplace add microsoft/power-platform-skills
/plugin install power-pages@power-platform-skills

This installs the whole power-pages plugin with all its skills

2Skills CLI (Vercel)

npx skills add microsoft/power-platform-skills --skill add-sample-data -a claude-code

3Manually: put the files in place

~/.claude/skills/add-sample-data/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/add-sample-data/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about add-sample-data

How do I install add-sample-data in Claude Code?

Run in order: /plugin marketplace add microsoft/power-platform-skills, then /plugin install power-pages@power-platform-skills, then npx skills add microsoft/power-platform-skills --skill add-sample-data -a claude-code, and finally send ~/.claude/skills/add-sample-data/SKILL.md to Claude Code.

What does add-sample-data do?

It generates and inserts sample records into your Dataverse tables via OData. The skill reads column names and types, creates realistic values (names for Name fields, emails for Email columns, dates within a reasonable range), respects relationships so parent tables are populated first, and shows you a preview before inserting.

Do I need PAC CLI and Azure CLI?

Yes. The skill uses PAC CLI to authenticate with Power Platform and Azure CLI to fetch an access token for the Dataverse API.

Source text

SKILL.md · MIT
---
name: add-sample-data
description: >-
  Populates Dataverse tables with sample records for testing and demoing a Power Pages site.
  Use when the user wants to add sample data, seed data, generate test records, or insert
  demo data into their tables.
user-invocable: true
allowed-tools: Read, Write, Bash, Grep, Glob, AskUserQuestion, Task, TaskCreate, TaskUpdate, TaskList, mcp__plugin_power-pages_microsoft-learn__microsoft_docs_search, mcp__plugin_power-pages_microsoft-learn__microsoft_code_sample_search, mcp__plugin_power-pages_microsoft-learn__microsoft_docs_fetch
model: sonnet
---

> **Plugin check**: Run `node "${PLUGIN_ROOT}/scripts/check-version.js"` — if it outputs a message, show it to the user before proceeding.

# Add Sample Data

Populate Dataverse tables with sample records via OData API so users can test and demo their Power Pages sites.

## Core Principles

- **Respect insertion order**: Always insert parent/referenced tables before child/referencing tables so lookup IDs are available when needed.
- **Use TaskCreate/TaskUpdate**: Track all progress throughout all phases -- create the todo list upfront with all phases before starting any work.
- **Fail gracefully**: On insertion failure, log the error and continue with remaining records -- never attempt automated rollback.

**Initial request:** $ARGUMENTS

---

## Phase 1: Verify Prerequisites

**Goal**: Confirm PAC CLI auth, acquire an Azure CLI token, and verify API access

**Actions**:

1. Create todo list with all 6 phases (see [Progress Tracking](#progress-tracking) table)
2. Follow the prerequisite steps in `${PLUGIN_ROOT}/references/dataverse-prerequisites.md` to verify PAC CLI auth, acquire an Azure CLI token, and confirm API access. Note the environment URL as `<envUrl>` for subsequent script calls.

**Output**: Authenticated session with valid token and confirmed API access

---

## Phase 2: Discover Tables

**Goal**: Find the custom tables available in the user's Dataverse environment

**Actions**:

### Path A: Read `.datamodel-manifest.json` (Preferred)

Check if `.datamodel-manifest.json` exists in the project root (written by the `setup-datamodel` skill). If it exists, read it -- it already contains table logical names, display names, and column info.

See `${PLUGIN_ROOT}/references/datamodel-manifest-schema.md` for the full manifest schema.

### Path B: Query OData API (Fallback)

If no manifest exists, discover custom tables via OData:

```
node "${PLUGIN_ROOT}/scripts/dataverse-request.js" <envUrl> GET "EntityDefinitions?\$select=LogicalName,DisplayName,EntitySetName&\$filter=IsCustomEntity eq true"
```

For each discovered table, fetch its custom columns:

```
node "${PLUGIN_ROOT}/scripts/dataverse-request.js" <envUrl> GET "EntityDefinitions(LogicalName='<table>')/Attributes?\$select=LogicalName,DisplayName,AttributeType,RequiredLevel&\$filter=IsCustomAttribute eq true"
```

### 2.1 Present Available Tables

Show the user the list of discovered tables with their columns so they can choose which to populate.

**Output**: List of discovered tables with their columns presented to the user

---

## Phase 3: Select Tables & Configure

**Goal**: Gather user preferences on which tables to populate and how many records to create

**Actions**:

### 3.1 Select Tables

<!-- gate: add-sample-data:3.1.tables | category=plan | cancel-leaves=nothing -->

> 🚦 **Gate (plan · add-sample-data:3.1.tables):** Multi-select over discovered tables — decides which tables get populated with sample data.
>
> **Trigger:** Phase 2 discovery completed.
> **Why we ask:** Auto-selecting all tables can pollute production-shape tables (e.g. `contact`) with throwaway records.
> **Cancel leaves:** Nothing — no record inserts yet.

Use `AskUserQuestion` to ask which tables they want to populate (use `multiSelect: true`). List all discovered tables as options.

### 3.2 Select Record Count

<!-- gate: add-sample-data:3.2.count | category=plan | cancel-leaves=nothing -->

> 🚦 **Gate (plan · add-sample-data:3.2.count):** Pick records-per-table (5 / 10 / 25 / Custom). Custom branch is a follow-up free-text prompt under the same gate.
>
> **Trigger:** Tables selected in 3.1.
> **Why we ask:** Inserting hundreds of records can blow past Dataverse storage / API throttling budgets.
> **Cancel leaves:** Nothing — no record inserts yet.

Use `AskUserQuestion` to ask how many sample records per table:

| Option | Description |
|--------|-------------|
| **5 records** | Quick test -- just enough to verify the setup |
| **10 records** | Light demo data for basic testing |
| **25 records** | Fuller dataset for realistic demos |
| **Custom** | Let the user specify a number |

### 3.3 Determine Insertion Order

Analyze relationships between selected tables. Parent/referenced tables must be inserted first so their IDs are available for child/referencing table lookups.

Build the insertion order:

1. Tables with no lookup dependencies (parent tables) -- insert first
2. Tables that reference already-inserted tables -- insert next
3. Continue until all tables are ordered

**Output**: Confirmed table selection, record count, and insertion order

---

## Phase 4: Generate & Review Sample Data

**Goal**: Generate contextually appropriate sample records and get user approval before inserting

**Actions**:

### 4.1 Generate Contextual Sample Data

For each selected table, generate sample records with contextually appropriate values based on column names and types:

- **String columns**: Generate realistic values matching the column name (e.g., "Email" -> `[email protected]`, "Phone" -> `(555) 123-4567`, "Name" -> realistic names)
- **Memo columns**: Generate short descriptive text relevant to the column name
- **Integer/Decimal/Currency columns**: Generate reasonable numeric values
- **DateTime columns**: Generate dates within a sensible range (past year to next month)
- **Boolean columns**: Mix of `true` and `false` values
- **Picklist/Choice columns**: Query valid options first (see references/odata-record-patterns.md), then use actual option values
- **Lookup columns**: Reference records from parent tables that will be/were already inserted

### 4.2 Present Sample Data Preview

For each table, show a markdown table previewing the sample records directly in the conversation:

```markdown
### Project (cr123_project) -- 5 records

| Name | Description | Status | Start Date |
|------|-------------|--------|------------|
| Website Redesign | Modernize the corporate website | 100000000 (Active) | 2025-03-15 |
| Mobile App | Build iOS and Android app | 100000001 (Planning) | 2025-04-01 |
| ... | ... | ... | ... |
```

Show relationship handling: which lookup fields reference which parent table records.

**Output**: Sample data plan ready for insertion. Proceed directly to Phase 5.

---

## Phase 5: Insert Sample Data

**Goal**: Execute OData POST calls to create all approved sample records with correct relationship handling

**Actions**:

Refer to `references/odata-record-patterns.md` for full patterns.

### 5.1 Get Entity Set Names

For each table, get the entity set name (needed for the API URL):

```
node "${PLUGIN_ROOT}/scripts/dataverse-request.js" <envUrl> GET "EntityDefinitions(LogicalName='<table>')?\$select=EntitySetName"
```

### 5.2 Get Picklist Options

For any picklist/choice columns, query valid option values before insertion:

```
node "${PLUGIN_ROOT}/scripts/dataverse-request.js" <envUrl> GET "EntityDefinitions(LogicalName='<table>')/Attributes(LogicalName='<column>')/Microsoft.Dynamics.CRM.PicklistAttributeMetadata?\$expand=OptionSet"
```

Use the actual `Value` integers from the option set in your sample data.

### 5.3 Insert Parent Tables First

Insert records into parent/referenced tables first to capture their IDs:

```
node "${PLUGIN_ROOT}/scripts/dataverse-request.js" <envUrl> POST "<EntitySetName>" --body '{"cr123_name":"Sample Record","cr123_description":"A sample record for testing"}' --include-headers
```

The `--include-headers` flag includes the `OData-EntityId` response header, which contains the created record ID. Parse the GUID from the response to use in child table lookups.

Store parent record IDs for use in child table lookups.

### 5.4 Insert Child Tables with Lookups

For child/referencing tables, use `@odata.bind` syntax to set lookup fields:

```
node "${PLUGIN_ROOT}/scripts/dataverse-request.js" <envUrl> POST "<ChildEntitySetName>" --body '{"cr123_name":"Child Record","[email protected]":"/<ParentEntitySetName>(<parent_guid>)"}' --include-headers
```

### 5.5 Track Progress

Track each insertion attempt:

- Record table name, record number, success/failure
- On failure, log the error message but continue with remaining records
- Do NOT attempt automated rollback on failure

### 5.6 Refresh Token Periodically

The `dataverse-request.js` script handles 401 token refresh internally. For long-running operations (many records), periodically re-run `verify-dataverse-access.js` to confirm the session is still valid:

```
node "${PLUGIN_ROOT}/scripts/verify-dataverse-access.js" <envUrl>
```

**Output**: All approved records inserted with parent-child relationships established

---

## Phase 6: Verify & Summarize

**Goal**: Confirm record counts and present a final summary to the user

**Actions**:

### 6.1 Verify Record Counts

For each table that was populated, query the record count:

```
node "${PLUGIN_ROOT}/scripts/dataverse-request.js" <envUrl> GET "<EntitySetName>?\$count=true&\$top=0"
```

The `@odata.count` field in the response gives the total record count.

### 6.2 Record Skill Usage

> Reference: `${PLUGIN_ROOT}/references/skill-tracking-reference.md`

Follow the skill tracking instructions in the reference to record this skill's usage. Use `--skillName "AddSampleData"`.

### 6.3 Present Summary

Present a summary table:

| Table | Records Requested | Records Created | Failures |
|-------|-------------------|-----------------|----------|
| `cr123_project` (Project) | 10 | 10 | 0 |
| `cr123_task` (Task) | 10 | 9 | 1 |

Include:

- Total records created across all tables
- Any failures with error details
- Lookup relationships that were established

### 6.4 Suggest Next Steps

After the summary, suggest:

- Review the data in the Power Pages maker portal or model-driven app
- If the site is not yet built: `/create-site`
- If the site is ready to deploy: `/deploy-site`

**Output**: Verified record counts and summary presented to the user

---

## Important Notes

### Throughout All Phases

- **Use TaskCreate/TaskUpdate** to track progress at every phase
- **Ask for user confirmation** at key decision points (see list below)
- **Respect insertion order** -- always insert parent tables before child tables
- **Fail gracefully** -- log errors and continue, never rollback automatically
- **Refresh tokens** every 20 records to avoid expiration

### Key Decision Points (Wait for User)

1. After Phase 2: Confirm which tables to populate
2. After Phase 3: Confirm record count and insertion order
3. After Phase 6: Review summary and decide next steps

### Progress Tracking

Before starting Phase 1, create a task list with all phases using `TaskCreate`:

| Task subject | activeForm | Description |
|-------------|------------|-------------|
| Verify prerequisites | Verifying prerequisites | Confirm PAC CLI auth, acquire Azure CLI token, verify API access |
| Discover tables | Discovering tables | Read .datamodel-manifest.json or query OData API for custom tables |
| Select tables and configure | Configuring tables | User picks tables, record count, and determine insertion order |
| Generate and review sample data | Generating sample data | Generate contextual sample records, present preview, get user approval |
| Insert sample data | Inserting records | Execute OData POST calls with relationship handling and token refresh |
| Verify and summarize | Verifying results | Confirm record counts, present summary, suggest next steps |

Mark each task `in_progress` when starting it and `completed` when done via `TaskUpdate`. This gives the user visibility into progress and keeps the workflow deterministic.

---

**Begin with Phase 1: Verify Prerequisites**

© Microsoft · MIT · microsoft/power-platform-skills

Similar skills

All skills for Agent setup: memory, context, orchestration →

add-sample-data by other authors comes first.

add-sample-data Microsoft add-sample-data is a Claude Code skill that populates Dataverse tables with realistic, schema-matched records in dependency order, so a newly created app has complete data on first load. CX Codex +1 ★ 1,167repo stars MCP Dataverse codeurali Connects AI coding assistants directly to Microsoft Dataverse for live schema inspection, FetchXML queries, and batch record updates. CX Codex +1 ★ 18repo stars dataverse-python-sdk official github dataverse-python-sdk is a GitHub Copilot rule that adds official Dataverse SDK for Python (preview) patterns for connection setup, CRUD, pagination, and file uploads. CX Codex +1 ★ 41,430repo stars dataverse-python-api-reference official github dataverse-python-api-reference — a GitHub Copilot rule that keeps a Dataverse Python SDK reference in the agent's context: client methods, config fields, error type. CX Codex +1 ★ 41,430repo stars azure-devops MicrosoftDocs A skill for Claude Code and Codex providing engineering guidance for Azure DevOps administration. Assists with permission audits, Managed DevOps Pools setup, and OData analytics queries. CX Codex +1 442installs test-data-management kindlmann test-data-management is a Claude Code skill for building isolated test factories and deterministic seeds, and setting up PII anonymization with synthetic entities. CX Codex +1 1,700installs security-generate-security-sample-data elastic security-generate-security-sample-data generates synthetic security events, attack scenarios and alerts for Elastic Security. Useful for demos, detection rule testing and POCs. CX Codex +1 4,200installs

From the same set157

The whole set →
preview-screens preview-screens generates a standalone HTML preview of mobile screens inside a 375 × 812 phone frame without starting Metro or a simulator. CX Codex +1 ★ 1,167repo stars build-flow build-flow turns a written request into a Power Automate flow, checks its definition, then creates it. Use it when you want an agent to assemble a flow from a description. CX Codex +1 ★ 1,167repo stars manage-headers manage-headers is a skill that inspects and configures Power Pages security headers, including CSP, frame protection, CORS, and cookie settings. CX Codex +1 ★ 1,167repo stars author-webpage-content The author-webpage-content skill for Claude Code generates and updates localized HTML for PAC CLI-downloaded Power Pages sites, building Design Studio layouts without manual tag edits. CX Codex +1 ★ 1,167repo stars enable-tables-offline enable-tables-offline is a Power Platform skill that sets IsAvailableOffline and ChangeTrackingEnabled on Dataverse tables so they can be added to a Mobile Offline Profile. CX Codex +1 ★ 1,167repo stars generate-mcp-app-ui generate-mcp-app-ui builds single-file HTML widgets for MCP tools using test JSON output, supporting fully self-contained builds or public CDN scripts. CX Codex +1 ★ 1,167repo stars generate-codeful-mcp-tool The generate-codeful-mcp-tool skill builds a JavaScript server runtime and registration metadata for a codeful MCP tool. Use it for Dataverse-backed tools or an MCP App widget. CX Codex +1 ★ 1,167repo stars scan-site scan-site scans a live Power Pages site for security issues and turns the report into plain language. Handy before a production push, or when you need fresh findings. CX Codex +1 ★ 1,167repo stars

Project sponsors

Companies that keep this analytics open