Study guide

10.2 Variables, Data Operations & Dynamic Content Manipulation

Microsoft Power Platform Functional Consultant PL-200

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Dataverse Tables, Relationships & Core Columns

1.1 Dataverse Table Types, Properties & Ownership 1.2 Table Relationships & Cascading Rules 1.3 Column Types, Formats, Primary Keys & Alternate Keys 1.4 Rollup, Calculated & Formula Columns with Power Fx

2 Chapter 2: Dataverse Data Management & Governance

2.1 Dataverse Search, Quick Find & Relevance Indexing 2.2 Auditing Configuration & Log Management 2.3 Duplicate Detection Rules & Settings 2.4 Bulk Record Operations, Data Import, Export & Templates

3 Chapter 3: Dataverse Security Model & Access Control

3.1 Business Units, Ownership Models & Modern BU Matrix 3.2 Security Roles, Privileges & Depth Levels 3.3 Teams Architecture: Owner, Access, and Microsoft Entra (AAD) Group Teams 3.4 Column-Level Security & Hierarchy Security Models

4 Chapter 4: Model-Driven App Fundamentals & Information Architecture

4.1 Model-Driven App Design, Site Map Navigation & Modern App Designer 4.2 Form Types: Main, Quick Create, Quick View & Card Forms 4.3 View Configuration, System Views, Personal Views & Filters

5 Chapter 5: Advanced Model-Driven App Components & Custom Pages

5.1 Custom Pages & Modern Commanding with Power Fx 5.2 Form Component Controls & Specialized UX Elements 5.3 Embedding Canvas Apps in Model-Driven Forms 5.4 Embedding Power BI Reports, Dashboards & Tiles

6 Chapter 6: Canvas Apps Structure, Formulas & Data Operations

6.1 Canvas App Architecture, Screens, Containers & Controls 6.2 Power Fx Formulas, Delegation & Data Source Limits 6.3 Variables (Context, Global), Collections & State Management 6.4 Triggering Power Automate Cloud Flows from Canvas Apps

7 Chapter 7: Power Pages Site Design, Navigation & Content

7.1 Power Pages Design Studio & Site Structure 7.2 Power Pages Templates, Styling & Responsive Layouts 7.3 Web Pages, Navigation Menus & Content Snippets

8 Chapter 8: Power Pages Data Integration, Forms & Web Roles

8.1 Power Pages Lists, Basic Forms & Advanced Forms 8.2 Table Permissions, Web Roles & Page Access Security 8.3 External Identity Providers & Authentication Configuration

9 Chapter 9: Power Automate Cloud Flow Fundamentals & Triggers

9.1 Cloud Flow Types: Automated, Instant, Scheduled & Desktop Overview 9.2 Dataverse Connector Triggers & Operational Filters 9.3 Standard Connectors, Custom Connectors & Connection References

10 Chapter 10: Cloud Flow Actions, Expressions & Logic Controls

10.1 Logic Controls: Conditions, Switches, Apply to Each & Do Until Loops 10.2 Variables, Data Operations & Dynamic Content Manipulation 10.3 Power Automate Expression Language (WDL / Functions) 10.4 Error Handling, Configure Run After & Scope Controls

11 Chapter 11: Business Process Flows & Guided Processes

11.1 Business Process Flow Architecture, Stages, Steps & Data Steps 11.2 Branching Rules & Multi-Entity Business Process Flows 11.3 BPF Action Steps, Workflows & Cloud Flow Execution 11.4 BPF Security Roles, Order & Process Lifecycle

12 Chapter 12: Classic Workflows, Business Rules & Modern Logic Extensibility

12.1 Classic Dataverse Workflows: Real-Time vs. Background (Async) 12.2 Business Rules: Scope & Actions 12.3 Low-Code Plug-ins in Dataverse: Automated vs. Instant 12.4 Troubleshooting Automations, Run History & Analytics

13 Chapter 13: Power Platform Environment Architecture & Security

13.1 Environment Types: Default, Sandbox, Production, Trial, Developer 13.2 Environment Governance, Groups, Routing & Capacity Management 13.3 Data Loss Prevention (DLP) Policies & Connector Classifications

14 Chapter 14: Application Lifecycle Management (ALM) & Solutions

14.1 Unmanaged vs. Managed Solutions & Solution Layering Mechanics 14.2 Solution Components, Dependencies, Publishers & Prefixes 14.3 Exporting, Importing, Upgrading & Patches 14.4 Solution Checker, App Checker & ALM Best Practices

15 Chapter 15: Enterprise Interoperability & Service Integration

15.1 Exchange / Server-Side Synchronization & Email Integration 15.2 SharePoint & OneDrive Document Management Integration 15.3 Microsoft Word & Excel Document Templates

16 Chapter 16: Copilot, AI Capabilities & Exam Strategy

16.1 Copilot Studio & Generative AI across Power Platform 16.2 AI Builder Prebuilt & Custom Models in Apps and Flows 16.3 PL-200 Exam Strategy, Time Management & Question Analysis

10.2 Variables, Data Operations & Dynamic Content Manipulation

Key Takeaways Explain This Topic AI

Variables in Power Automate are stateful, globally scoped containers; 'Initialize variable' actions MUST reside at the flow's top root level and cannot be placed inside scopes or conditional branches.

Power Automate supports six variable data types: Boolean, Integer, Float, String, Object, and Array, modified via Set, Increment, Decrement, Append to string, and Append to array actions.

Data Operations (Compose, Parse JSON, Select, Filter array, Join, Create CSV/HTML table) are stateless, highly performant, in-memory operations that eliminate costly loop-and-append patterns.

Parse JSON converts raw JSON payloads into strongly typed dynamic content tokens using a JSON Schema, which can be automatically inferred from a sample payload.

The Select action transforms array structures by projecting and renaming properties, while Filter array extracts subsets matching boolean criteria without iterating through an Apply to each container.

Last updated: August 2026

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

Variable Type Underlying JSON Type Description & Example Use Case

Boolean boolean true or false . Flagging whether a customer requires manual credit review.

Integer integer 64-bit signed whole number (e.g., 42 , -10 ). Counting processed invoice rows.

Float number Double-precision decimal number (e.g., 99.95 , 0.05 ). Storing tax percentages or currency balances.

String string Unicode text. Accumulating formatted notes or constructing an email body.

Object object JSON key-value dictionary (e.g., {"id": 101, "tier": "Gold"} ). Storing structured metadata.

Array array Ordered collection of scalars or JSON objects (e.g., ["A", "B", "C"] ). Accumulating record GUIDs.

2. Variable Manipulation Actions

Action Name Compatible Types Operational Behavior

Set variable All types Completely overwrites the existing value with a new value of the same type.

Increment variable Integer , Float Increases the variable by a specified positive or negative numeric value.

Decrement variable Integer , Float Decreases the variable by a specified positive or negative numeric value.

Append to string variable String Appends text to the end of the existing string value without overwriting.

Append to array variable Array Appends a new element (scalar value or JSON object) to the end of the array.

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

Architectural Feature Variables Data Operations

State Model Stateful & Mutable (Values change over time) Stateless & Immutable (Outputs never change once created)

Placement Constraints Initialize variable must be at root level Can be placed anywhere (inside Scopes, Conditions, Loops)

Loop Concurrency Safety Unsafe in parallel loops; requires Degree of Parallelism = 1 Completely thread-safe (stateless)

Performance Profile Slow when modified repeatedly inside loops Ultra-fast in-memory processing of 5,000+ items in milliseconds

API / Action Consumption Consumes 1 action execution per loop iteration Consumes 1 single action execution for the entire dataset

Primary Use Cases Counters, flags, accumulating state across disparate steps Reshaping arrays, generating tables, filtering collections, parsing JSON