10.2 Variables, Data Operations & Dynamic Content Manipulation

Variables, Data Operations & Dynamic Content Manipulation

Efficient cloud flow design requires a clear separation between stateful variable management and declarative data transformation. While variables provide mutable storage across a flow's execution lifecycle, relying on loops and variable mutations to reshape data introduces performance bottlenecks and thread-safety risks. Microsoft Power Automate provides the built-in Data Operations suite to perform high-speed, in-memory manipulations on JSON objects and arrays without procedural looping.

For the PL-200: Microsoft Power Platform Functional Consultant exam, you must know when to use variables versus data operations, understand root-level variable initialization constraints, master JSON schema extraction with Parse JSON, and leverage declarative actions like Select, Filter array, and Join.

---

1. Variables Architecture & Scope Rules

A Variable is a named, mutable memory container allocated in the flow runtime environment. Once initialized, a variable can be read, updated, incremented, or appended to by any downstream action across the flow.

+-----------------------------------------------------------------------------+
|                        VARIABLE LIFECYCLE & ACTIONS                         |
|                                                                             |
|   [ROOT LEVEL OF FLOW]                                                      |
|   +---------------------------------------------------------------------+   |
|   | ACTION: Initialize variable                                         |   |
|   | - Name:        varCustomerSummary                                   |   |
|   | - Type:        String, Integer, Float, Boolean, Object, Array       |   |
|   | - Value:       Initial payload (optional)                           |   |
|   +---------------------------------------------------------------------+   |
|                                     |                                       |
|                                     v                                       |
|   [DOWNSTREAM ACTIONS / BRANCHES / LOOPS]                                   |
|   +---------------------------------------------------------------------+   |
|   | - Set variable:                Overwrites current value             |   |
|   | - Increment / Decrement:       Adds / subtracts numeric offset      |   |
|   | - Append to string variable:   Concatenates text to string          |   |
|   | - Append to array variable:    Pushes item/object into array        |   |
|   +---------------------------------------------------------------------+   |
+-----------------------------------------------------------------------------+

The Root-Level Initialization Rule

In Power Automate, Initialize variable actions can ONLY be placed at the root level of the flow. They cannot be nested inside any container action, including:

• Scope containers
• Condition (If yes / If no branches)
• Switch (Case or Default branches)
• Apply to each loops
• Do Until loops

If you need to assign a variable conditionally, you must initialize the variable at the top of the flow (with an empty or default value) and use Set variable inside the conditional branch.

Supported Variable Data Types

---

2. Variable Manipulation Actions

---

3. Data Operations Suite

The built-in Data Operations connector provides high-speed, in-memory tools for reshaping, filtering, parsing, and converting data payloads. Unlike variables, Data Operations are stateless and produce immutable output tokens.

+-----------------------------------------------------------------------------+
|                           DATA OPERATIONS ECOSYSTEM                         |
|                                                                             |
|   [COMPOSE]            ---> Evaluates expressions, formats scratchpad data  |
|   [PARSE JSON]         ---> Generates typed dynamic tokens from JSON string |
|   [SELECT]             ---> Projects and reshapes array objects             |
|   [FILTER ARRAY]       ---> Extracts matching items without looping         |
|   [JOIN]               ---> Flattens array into delimited string (e.g. '; ')|
|   [CREATE CSV TABLE]   ---> Converts JSON array into comma-separated text   |
|   [CREATE HTML TABLE]  ---> Converts JSON array into HTML <table> markup    |
+-----------------------------------------------------------------------------+

1. Compose Action

The Compose action evaluates any expression, static text, or dynamic token and stores the result as an immutable output (outputs('Compose_Name')). Common uses:

• Creating reusable constants or complex WDL calculations (e.g., calculating tax amounts once and referencing the output multiple times).
• Constructing ad-hoc JSON payloads for downstream HTTP calls.
• Debugging expressions by inspecting step inputs and outputs in run history.

2. Parse JSON Action

Cloud APIs and HTTP actions often return unformatted JSON strings. While Power Automate can store the string, individual properties are inaccessible as dynamic content. Parse JSON analyzes the string against a JSON Schema and generates strongly typed dynamic tokens.

+-----------------------------------------------------------------------------+
|                        PARSE JSON WORKFLOW PIPELINE                         |
|                                                                             |
|   [RAW JSON STRING (HTTP Payload)]                                          |
|   '{"customerId": "C-892", "creditLimit": 75000, "active": true}'            |
|                 |                                                           |
|                 v                                                           |
|   +---------------------------------------------------------------------+   |
|   | ACTION: Parse JSON                                                  |   |
|   | Content: body('HTTP_Call')                                          |   |
|   | Schema:  {"type": "object", "properties": { ... }}                   |   |
|   +---------------------------------------------------------------------+   |
|                 |                                                           |
|                 +---> (Click 'Use sample payload to generate schema')       |
|                 |                                                           |
|                 v                                                           |
|   [EXPOSED DYNAMIC CONTENT TOKENS]                                          |
|   - customerId (String)  |  creditLimit (Integer)  |  active (Boolean)      |
+-----------------------------------------------------------------------------+

[!TIP] Handling Null Values in JSON Schemas: If an incoming API payload contains a property that might be null (e.g., "middleName": null), a strict schema "type": "string" will throw a runtime BadRequest validation error. Edit the schema manually to allow nullable types: "type": ["string", "null"] or "type": ["integer", "null"].

3. Select Action (Array Transformation)

The Select action transforms an array of objects into a new array with a modified structure or fewer attributes. It takes an input array (From) and evaluates a mapping dictionary (Map) for every element in a single, lightning-fast in-memory operation.

// Input Array (From: Dataverse 'List rows'):
[
  {"accountid": "001", "name": "Contoso Ltd", "revenue": 500000, "address1_city": "Seattle"},
  {"accountid": "002", "name": "Fabrikam Inc", "revenue": 250000, "address1_city": "Dallas"}
]

// Select Mapping Definition:
// AccountName  --> item()?['name']
// City         --> item()?['address1_city']

// Output Array of Select action:
[
  {"AccountName": "Contoso Ltd", "City": "Seattle"},
  {"AccountName": "Fabrikam Inc", "City": "Dallas"}
]

4. Filter Array Action

The Filter array action extracts a subset of elements from an array that meet specific boolean criteria. It accepts an input array (From) and evaluates a condition row (e.g., item()?['revenue'] is greater than 300000). Only items where the condition evaluates to true are included in body('Filter_array').

5. Join Action

The Join action takes an array of strings or scalars and concatenates them into a single string separated by a specified delimiter.

Input Array:   ["alice@contoso.com", "bob@contoso.com", "charlie@contoso.com"]
Join Delimiter: "; "
Output String: "alice@contoso.com; bob@contoso.com; charlie@contoso.com"

6. Create CSV Table & Create HTML Table

These actions convert an array of JSON objects into structured tables:

• Create CSV table: Outputs standard comma-delimited text, perfect for generating flat file attachments.
• Create HTML table: Outputs an HTML <table>...</table> markup string, ideal for embedding directly into automated notification emails or Teams messages.
• Columns Property: Set to Automatic (inherits all object keys as headers) or Custom (allows defining explicit column header names and mapped expression values).

---

4. The Anti-Pattern: Loops vs. Declarative Pipelines

A critical functional skill tested on the PL-200 exam is replacing inefficient, procedural loops with declarative Data Operations.

+-----------------------------------------------------------------------------+
|             PROCEDURAL ANTI-PATTERN VS DECLARATIVE PIPELINE                 |
|                                                                             |
|   [ANTI-PATTERN: LOOP & APPEND]             [RECOMMENDED: DATA OPERATIONS]  |
|   - 'List rows' (5,000 records)             - 'List rows' (5,000 records)   |
|   - Apply to each (Sequential)              - Filter array (High value)     |
|     - Condition (Revenue > 50K)             - Select (Project Name/Email)   |
|       - Append to array variable            - Join (Delimiter '; ')         |
|   Execution Time: 5 to 15 minutes           Execution Time: < 1.5 seconds   |
|   API Calls Consumed: 5,000+                API Calls Consumed: 3           |
+-----------------------------------------------------------------------------+

---

5. Architectural Comparison: Variables vs. Data Operations