Powerplatform

PowerPlatform - Flow Generation Skill

Generate Power Automate flows from natural language descriptions using connector schemas exported from your work environment.

Workflow Routing

Power Platform has no Workflows/ directory — each request routes to a starting template in templates/ (customized against the connector schemas), then packages via tools/package-solution.sh. Reference examples in examples/ show finished flows.

Trigger phrase	Starting template	Reference
"notify", "send a message when", "alert on new email/item"	`templates/notification-flow.json`	`examples/urgent-email-teams-notification.json`
"approval", "route for sign-off", "approve/reject"	`templates/approval-flow.json`	`examples/sharepoint-item-approval.json`
"scheduled report", "every week/day send", "recurring summary"	`templates/scheduled-report.json`	`examples/weekly-report.json`
"save attachments", "process incoming email files"	`templates/email-attachment-handler.json`	`reference/actions.md`
Anything else / build from scratch	build inline from schema	`reference/expressions.md`, `reference/triggers.md`, `reference/actions.md`

Always start by reading ~/Projects/work/scripts/power-platform/manifest.json to confirm the needed connectors are available before generating.

Examples

Example 1: Teams notification on urgent email

User: "When an urgent email arrives in my work inbox, post it to the Ops Teams channel"
-> Reads manifest.json → confirms shared_office365 + shared_teams available
-> Starts from templates/notification-flow.json
-> Trigger: When_a_new_email_arrives (Office365), condition on importance = high
-> Action: Post_message_in_a_chat_or_channel (Teams)
-> Packages via tools/package-solution.sh
-> Saves to ~/Projects/work/scripts/power-platform/generated/urgent-email-notify.zip

Example 2: Document approval workflow

User: "Make a flow for document approval - when a file is added to SharePoint, start an approval, then move to approved/rejected folder"
-> Starts from templates/approval-flow.json
-> Trigger: When_a_file_is_created (SharePoint)
-> Action: Start_and_wait_for_an_approval (Approvals)
-> Condition branches on outcome → Update_item to move to approved/rejected library
-> Outputs deployable solution ZIP for import at work

Example 3: Scheduled weekly report

User: "Every Monday at 8am, pull last week's list items and email me a summary"
-> Starts from templates/scheduled-report.json
-> Trigger: Recurrence (Schedule), weekly on Monday 08:00
-> Action: Get_items (SharePoint) + Apply_to_each to build HTML table
-> Action: Send_an_email (Office365) with @{length(body('Get_items')?['value'])} count
-> Saves to generated/ as weekly-report.zip

Architecture

Work Repo (schemas)                    PAI (this skill)
~/Projects/work/scripts/               ~/.claude/skills/PowerPlatform/
power-platform/
├── connectors/          ──reads──>    ├── SKILL.md
│   ├── shared_teams.json              ├── templates/
│   ├── shared_outlook.json            ├── reference/
│   └── ...                            └── examples/
├── manifest.json
└── generated/           <──writes──   [Solution ZIPs]

Workflow

1. Check Available Connectors

Before generating, read the manifest to see what connectors are available:

cat ~/Projects/work/scripts/power-platform/manifest.json

If manifest.json doesn't exist or is stale, inform user to run the export script at work.

2. Parse User Request

Extract from natural language:

Trigger: What starts the flow (email arrives, file created, scheduled, manual)
Actions: What the flow does (send message, create item, update record)
Conditions: Any branching logic (if/then, switch)
Data flow: What data passes between steps

3. Generate Flow Definition

Create the flow JSON following Power Automate schema. Key structure:

{
  "properties": {
    "definition": {
      "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
      "triggers": { ... },
      "actions": { ... }
    },
    "connectionReferences": { ... }
  }
}

4. Package as Solution

Wrap in solution structure for import:

solution/
├── [Content_Types].xml
├── customizations.xml
├── solution.xml
└── Workflows/
    └── {flow-guid}-{flow-name}.json

5. Output

Save to: ~/Projects/work/scripts/power-platform/generated/

Connection References

Flows use connection references that map to actual connections in the target environment. Use placeholder IDs that will be resolved on import:

"connectionReferences": {
  "shared_teams": {
    "connectionName": "shared_teams",
    "source": "Embedded",
    "id": "/providers/Microsoft.PowerApps/apis/shared_teams",
    "tier": "NotSpecified"
  }
}

On import, Power Platform prompts user to map these to their actual connections.

Expression Syntax

Power Automate uses a specific expression language. Common patterns:

Dynamic Content References

@{triggerOutputs()?['body/subject']}           # Email subject from trigger
@{body('Get_item')?['Title']}                  # Field from previous action
@{items('Apply_to_each')?['name']}             # Current item in loop

Functions

@{utcNow()}                                    # Current timestamp
@{concat('Hello ', triggerBody()?['name'])}   # String concatenation
@{if(equals(1,1),'yes','no')}                 # Conditional
@{length(body('Get_items')?['value'])}        # Array length
@{formatDateTime(utcNow(),'yyyy-MM-dd')}      # Date formatting

Conditions

"expression": {
  "and": [
    { "contains": ["@triggerOutputs()?['body/subject']", "urgent"] },
    { "equals": ["@triggerOutputs()?['body/importance']", "high"] }
  ]
}

See reference/expressions.md for full syntax guide.

Common Triggers

Trigger	Connector	Use Case
`When_a_new_email_arrives`	Office365	Email automation
`When_a_file_is_created`	SharePoint	Document workflows
`When_an_item_is_created`	SharePoint	List automation
`When_a_row_is_added`	Dataverse	Database triggers
`Recurrence`	Schedule	Scheduled jobs
`manual`	Manual	Button-triggered
`When_a_HTTP_request_is_received`	HTTP	Webhook/API trigger

Common Actions

Action	Connector	Use Case
`Send_an_email`	Office365	Email notifications
`Post_message_in_a_chat_or_channel`	Teams	Team notifications
`Create_item`	SharePoint	Add list items
`Update_item`	SharePoint	Modify list items
`Start_and_wait_for_an_approval`	Approvals	Approval workflows
`Create_a_row`	Dataverse	Database writes
`HTTP`	HTTP	External API calls

Templates

Pre-built patterns in templates/:

approval-flow.json - Standard approval workflow
notification-flow.json - Event-triggered notifications
scheduled-report.json - Scheduled data collection
form-processing.json - Forms response handling
file-sync.json - Cross-system file operations

Generation Process

When asked to create a flow:

Read available schemas:

ls ~/Projects/work/scripts/power-platform/connectors/
cat ~/Projects/work/scripts/power-platform/manifest.json

Load relevant connector schemas for the requested functionality
Select appropriate template or build from scratch
Generate flow JSON with:
- Unique GUID for flow
- Proper trigger configuration
- Action sequence with correct operation IDs
- Connection references for all connectors used
- Expression syntax for dynamic content
Create solution package using tools/package-solution.sh
Save to generated folder and inform user

Limitations

Cannot deploy directly - User must import at work
Connection mapping required - User maps connections on import
Premium connectors - Some require premium licenses
Custom connectors - Not supported without schema export
Schema freshness - Depends on export frequency at work

Files Reference

File	Purpose
`templates/*.json`	Pre-built flow patterns
`reference/expressions.md`	Expression syntax guide
`reference/triggers.md`	Trigger configurations
`reference/actions.md`	Action configurations
`examples/*.json`	Working example flows
`tools/package-solution.sh`	Solution packager script