ā† Back to Articles šŸ“š DEVLADBLOG
šŸ“ Power Automate

Advanced Expressions and Functions: Techniques

šŸ“… 2025-05-19 āœļø Vladimir Luis ā±ļø 17 min

Advanced Expressions and Functions: Techniques

Introduction

Power Automate expressions are the secret weapon for building efficient, maintainable flows. While visual actions provide a low-code interface, expressions enable sophisticated data transformations inline - without adding extra actions that consume API calls and slow execution. A single expression can replace 10+ actions, transforming a 500-action flow into a 50-action flow that runs 10Ɨ faster.

However, expressions have a reputation for being cryptic and hard to debug. Many makers avoid them, relying on multiple Compose, Parse JSON, and Apply to Each actions instead. This creates technical debt: flows that are slow, fragile, and difficult to maintain. Mastering expressions is the difference between amateur flows and production-grade automation.

This comprehensive guide covers 12 critical expression patterns: JSON parsing and object manipulation, array transformations (select, filter, union), string operations (regex, substring, replace), date/time calculations with timezones, null safety with coalesce and safe navigation, mathematical computations, logical operators, collection functions, type conversions, performance optimization, debugging techniques, and real-world enterprise use cases. By the end, you'll write expressions confidently and know when to use them versus visual actions.

Prerequisites

  • Power Automate license (Premium recommended for HTTP/custom connectors)
  • Understanding of JSON structure and data types
  • Familiarity with basic flow actions (Compose, Apply to Each, Condition)
  • Access to Power Automate expression reference: Official Documentation
  • Browser developer tools for JSON inspection (F12 in Chrome/Edge)
  • (Optional) VS Code with JSON extension for testing expressions offline

Core Expression Function Families

Power Automate provides 100+ functions organized into families. Understanding which family solves which problem is critical.

Comprehensive Function Family Reference

Family Primary Use Cases Key Functions When to Use
String Functions Text manipulation, parsing, formatting concat, replace, substring, toLower, toUpper, trim, split, length, indexOf, lastIndexOf, startsWith, endsWith Email parsing, file path manipulation, data cleanup, format standardization
Collection Functions Array transformation, filtering, aggregation length, first, last, union, intersection, join, skip, take, contains, empty Process SharePoint list items, filter datasets, combine arrays, check membership
Logical Functions Conditional logic, boolean operations if, and, or, not, equals, greater, less, coalesce Dynamic branching, null handling, multi-condition validation
Date/Time Functions Date arithmetic, formatting, timezone conversion utcNow, addDays, addHours, formatDateTime, convertTimeZone, ticks, dayOfWeek, dayOfYear SLA calculations, business hours checks, date formatting for APIs, timezone handling
Conversion Functions Type casting, data format transformation json, int, float, string, bool, base64, uriComponent, xml Parse JSON strings, convert numbers, encode URLs, XML processing
Math Functions Numerical operations, calculations add, sub, mul, div, mod, max, min, rand, range Price calculations, percentage computations, statistics, pagination
Workflow Functions Flow metadata, trigger data, context trigger(), body(), actions(), workflow(), parameters(), variables(), item(), items() Access flow execution context, action results, loop items, environment variables
Reference Functions Dynamic connections, schemas, templates concat, uriComponent, base64 (for dynamic connection references) Dynamic REST API calls, parameterized connectors

Function Family Decision Tree

Question 1: What type of data are you working with?

  • Text ā†’ String Functions (concat, substring, replace)
  • Numbers ā†’ Math Functions (add, mul, max, min)
  • Arrays ā†’ Collection Functions (select, filter, union)
  • Dates ā†’ Date/Time Functions (addDays, formatDateTime)
  • Objects/JSON ā†’ Workflow Functions + Conversion Functions

Question 2: What operation do you need?

  • Transform ā†’ select, replace, formatDateTime
  • Filter ā†’ filter, where, if
  • Aggregate ā†’ union, join, concat
  • Validate ā†’ contains, equals, empty
  • Extract ā†’ substring, first, last, body()

Question 3: Performance concern?

  • Replace loops ā†’ select, filter, union (inline array operations)
  • Avoid null errors ā†’ coalesce, safe navigation ?[]
  • Minimize actions ā†’ combine multiple operations in single expression

JSON Parsing and Object Manipulation

Problem: Parse JSON String from HTTP Response

HTTP connectors often return JSON as a string, not a parsed object. Accessing properties requires parsing.

Scenario: API returns {"customer": {"id": 12345, "name": "Acme Corp", "tier": "Gold"}}

Bad Approach (2 actions):

  1. Parse JSON action
  2. Access properties via dynamic content

Good Approach (1 expression):

json(body('HTTP_GetCustomer'))?['customer']?['id']

Complete Expression Breakdown:

  • body('HTTP_GetCustomer') - Get HTTP response body (string)
  • json(...) - Convert JSON string to object
  • ?['customer'] - Safe navigation to customer property (won't fail if null)
  • ?['id'] - Access id property

Full Flow Pattern:

{
  "Initialize_CustomerId": {
    "type": "InitializeVariable",
    "inputs": {
      "variables": [
        {
          "name": "CustomerId",
          "type": "integer",
          "value": "@json(body('HTTP_GetCustomer'))?['customer']?['id']"
        }
      ]
    }
  }
}

Advanced: Construct JSON Object Dynamically

Scenario: Build JSON payload for API from multiple sources

{
  "Compose_APIPayload": {
    "type": "Compose",
    "inputs": {
      "orderId": "@{variables('OrderNumber')}",
      "customer": {
        "email": "@{triggerBody()?['Editor']?['Email']}",
        "name": "@{concat(triggerBody()?['FirstName'], ' ', triggerBody()?['LastName'])}"
      },
      "items": "@variables('OrderItems')",
      "total": "@mul(variables('Quantity'), variables('UnitPrice'))",
      "timestamp": "@{utcNow()}"
    }
  }
}

Benefits:

  • No Parse JSON action needed (construct directly)
  • Type-safe (strings, integers, nested objects)
  • Reusable (outputs('Compose_APIPayload') for HTTP body)

Extract Nested Arrays from Complex JSON

Scenario: API returns deeply nested structure, need to extract array 3 levels deep

JSON Structure:

{
  "data": {
    "results": {
      "invoices": [
        {"invoiceId": "INV001", "amount": 500},
        {"invoiceId": "INV002", "amount": 750}
      ]
    }
  }
}

Expression:

json(body('HTTP_GetData'))?['data']?['results']?['invoices']

Use with Select to Transform:

select(
  json(body('HTTP_GetData'))?['data']?['results']?['invoices'],
  item()?['invoiceId']
)

Result: Array of invoice IDs: ["INV001", "INV002"]

Advanced Array Transformations

Pattern 1: Transform Array with Select (Replaces Apply to Each)

Problem: Process 1,000-item array, need to extract specific fields and rename

Inefficient Approach (1,000 actions):

  • Apply to Each loop
  • Inside: Compose action to extract fields
  • Append to array variable

Efficient Approach (1 expression):

select(
  variables('SourceItems'),
  {
    'EmployeeId': item()?['ID'],
    'FullName': concat(item()?['FirstName'], ' ', item()?['LastName']),
    'Email': toLower(item()?['Email']),
    'Department': coalesce(item()?['Department'], 'Unassigned'),
    'HireDate': formatDateTime(item()?['HireDate'], 'yyyy-MM-dd')
  }
)

Benefits:

  • 1 action vs 1,000 actions (99.9% reduction)
  • Executes in ~1 second vs ~100 seconds
  • No concurrency management needed

Real-World Use Case:
Transform SharePoint list items for bulk upload to SQL:

{
  "Select_EmployeesForSQL": {
    "type": "Select",
    "inputs": {
      "from": "@body('Get_items')?['value']",
      "select": {
        "EmployeeID": "@item()?['ID']",
        "FirstName": "@item()?['Title']",
        "LastName": "@item()?['LastName']",
        "EmailAddress": "@toLower(item()?['Email'])",
        "DepartmentCode": "@if(equals(item()?['Department'], 'Engineering'), 'ENG', if(equals(item()?['Department'], 'Sales'), 'SAL', 'OTH'))",
        "Salary": "@int(item()?['Salary'])",
        "IsActive": "@equals(item()?['Status'], 'Active')"
      }
    }
  }
}

Pattern 2: Filter Array (Replace Condition Inside Loop)

Problem: Filter 5,000-item array for specific criteria

Expression:

filter(
  variables('AllOrders'),
  and(
    equals(item()?['Status'], 'Pending'),
    greaterOrEquals(item()?['Amount'], 1000),
    less(item()?['DaysOpen'], 30)
  )
)

Multi-Condition Complex Filter:

filter(
  body('Get_items')?['value'],
  and(
    or(
      equals(item()?['Priority'], 'High'),
      equals(item()?['Priority'], 'Critical')
    ),
    equals(item()?['AssignedTo']?['Email'], variables('CurrentUserEmail')),
    greaterOrEquals(item()?['DueDate'], utcNow())
  )
)

Performance: Filter 5,000 items to 50 matching items in ~2 seconds (vs 5,000 Condition actions taking 100+ seconds)

Pattern 3: Union - Combine Arrays and Remove Duplicates

Scenario: Merge two approval lists, eliminate duplicate approvers

Expression:

union(
  body('Get_FinanceApprovers')?['value'],
  body('Get_LegalApprovers')?['value']
)

Deduplication: Automatically removes duplicates based on object equality

For Simple Arrays (strings):

union(
  variables('ApprovedEmails'),
  variables('AdditionalEmails')
)

Result: ["user1@contoso.com", "user2@contoso.com"] (duplicates removed)

Pattern 4: Intersection - Find Common Elements

Scenario: Find users in both "Managers" and "Certified" groups

Expression:

intersection(
  variables('ManagerEmails'),
  variables('CertifiedEmails')
)

Pattern 5: First, Last, Skip, Take - Array Slicing

Get First Item (Safe - Won't Fail on Empty Array):

first(variables('Items'))

Get Last 10 Items:

skip(variables('LogEntries'), sub(length(variables('LogEntries')), 10))

Pagination Pattern - Get Items 20-30:

take(skip(variables('AllItems'), 20), 10)

Pattern 6: Join - Array to Delimited String

Convert Array to Comma-Separated String:

join(variables('ApproverNames'), ', ')

Result: "John Doe, Jane Smith, Bob Jones"

Email List for "To" Field:

join(
  select(variables('Recipients'), item()?['Email']),
  ';'
)

Result: "user1@contoso.com;user2@contoso.com;user3@contoso.com"

String Manipulation Mastery

Pattern 1: Extract Substring - File Extension from Path

Scenario: Get file extension from SharePoint file path

Expression:

substring(
  variables('FilePath'),
  add(lastIndexOf(variables('FilePath'), '.'), 1)
)

Explanation:

  • lastIndexOf(variables('FilePath'), '.') - Find position of last dot
  • add(..., 1) - Skip the dot character
  • substring(...) - Extract from that position to end

Example: "/sites/HR/Documents/Policy.pdf" ā†’ "pdf"

Pattern 2: Replace - Data Cleanup

Remove Special Characters:

replace(
  replace(
    replace(variables('UserInput'), '\\', ''),
    '/', ''
  ),
  '|', ''
)

Nested Replace (Max 3 levels in single expression)

Better Approach for Multiple Replacements:

{
  "Set_CleanedText": {
    "type": "SetVariable",
    "inputs": {
      "name": "CleanedText",
      "value": "@replace(variables('UserInput'), '\\', '')"
    }
  },
  "Set_CleanedText2": {
    "type": "SetVariable",
    "inputs": {
      "name": "CleanedText",
      "value": "@replace(variables('CleanedText'), '/', '')"
    }
  }
}

Pattern 3: Split and Array Operations - Parse CSV

Scenario: Parse comma-separated email list

Expression:

split(variables('EmailListString'), ',')

With Trim to Remove Spaces:

select(
  split(variables('EmailListString'), ','),
  trim(item())
)

Example:

  • Input: "user1@contoso.com, user2@contoso.com , user3@contoso.com"
  • Output: ["user1@contoso.com", "user2@contoso.com", "user3@contoso.com"] (spaces removed)

Pattern 4: startsWith / endsWith - Conditional Processing

Check if File is PDF:

endsWith(toLower(triggerBody()?['{FilenameWithExtension}']), '.pdf')

Check if Email is from contoso.com Domain:

endsWith(toLower(triggerBody()?['Editor']?['Email']), '@contoso.com')

Check if Folder Path is HR Department:

startsWith(triggerBody()?['{Path}'], '/sites/HR/')

Pattern 5: indexOf - Find Position for Parsing

Extract Domain from Email:

substring(
  variables('Email'),
  add(indexOf(variables('Email'), '@'), 1)
)

Example: "john.doe@contoso.com" ā†’ "contoso.com"

Date and Time Calculations

Pattern 1: SLA Deadline Calculation

Scenario: Ticket created, set SLA deadline to 2 business days (skip weekends)

Expression (Simple - Doesn't Skip Weekends):

addDays(utcNow(), 2)

Expression (Advanced - Skip Weekends):

if(
  equals(dayOfWeek(addDays(utcNow(), 2)), 6),  // Saturday
  addDays(utcNow(), 4),                         // Push to Monday
  if(
    equals(dayOfWeek(addDays(utcNow(), 2)), 0), // Sunday
    addDays(utcNow(), 3),                        // Push to Monday
    addDays(utcNow(), 2)                         // Weekday, use 2 days
  )
)

Production Pattern (4-Hour SLA During Business Hours Only):

{
  "Calculate_SLA_Deadline": {
    "type": "Compose",
    "inputs": {
      "CreatedTime": "@utcNow()",
      "BusinessHoursStart": 9,
      "BusinessHoursEnd": 17,
      "SLA_Hours": 4,
      "Deadline": "@addHours(utcNow(), 4)"
    }
  }
}

Pattern 2: Convert Timezone for Local Display

UTC to Eastern Time:

convertTimeZone(
  utcNow(),
  'UTC',
  'Eastern Standard Time',
  'yyyy-MM-dd HH:mm:ss'
)

Timezone Codes:

  • Eastern: Eastern Standard Time
  • Central: Central Standard Time
  • Pacific: Pacific Standard Time
  • UK: GMT Standard Time
  • Full list: Microsoft Timezone Documentation

Pattern 3: Business Hours Check

Check if Current Time is Business Hours (9 AM - 5 PM):

and(
  greaterOrEquals(int(formatDateTime(utcNow(), 'HH')), 9),
  less(int(formatDateTime(utcNow(), 'HH')), 17)
)

Check if Weekday (Monday-Friday):

and(
  greater(dayOfWeek(utcNow()), 0),  // Not Sunday (0)
  less(dayOfWeek(utcNow()), 6)      // Not Saturday (6)
)

Combined Business Hours + Weekday Check:

and(
  and(
    greater(dayOfWeek(utcNow()), 0),
    less(dayOfWeek(utcNow()), 6)
  ),
  and(
    greaterOrEquals(int(formatDateTime(utcNow(), 'HH')), 9),
    less(int(formatDateTime(utcNow(), 'HH')), 17)
  )
)

Pattern 4: Date Formatting for APIs

Format for SQL Server:

formatDateTime(variables('DueDate'), 'yyyy-MM-dd HH:mm:ss')

Format for Dataverse (ISO 8601):

formatDateTime(variables('CreatedDate'), 'yyyy-MM-ddTHH:mm:ssZ')

Format for Display (US Format):

formatDateTime(variables('InvoiceDate'), 'MM/dd/yyyy')

Null Safety and Error Prevention

Pattern 1: Coalesce - Provide Default Values

Problem: Optional field may be null, causing flow failure

Expression:

coalesce(triggerBody()?['Department'], 'Unassigned')

Multiple Fallbacks:

coalesce(
  triggerBody()?['PreferredEmail'],
  triggerBody()?['WorkEmail'],
  triggerBody()?['PersonalEmail'],
  'noemail@contoso.com'
)

Real-World Use Case - Dynamic Approver Selection:

{
  "Get_ApproverEmail": {
    "type": "Compose",
    "inputs": "@coalesce(body('Get_Department')?['ManagerEmail'], variables('DefaultManagerEmail'), 'admin@contoso.com')"
  }
}

Pattern 2: Safe Navigation - Avoid Null Reference Errors

Problem: Nested object may have null properties at any level

Unsafe Expression (Will Fail if Editor is Null):

triggerBody()['Editor']['Email']

Safe Expression:

triggerBody()?['Editor']?['Email']

Explanation:

  • ?[] operator returns null instead of throwing error
  • Chain multiple levels: ?['level1']?['level2']?['level3']

Combined with Coalesce:

coalesce(triggerBody()?['Editor']?['Email'], 'unknown@contoso.com')

Pattern 3: Empty / Null Checks

Check if Array is Empty:

empty(variables('Items'))

Check if String is Null or Empty:

or(
  equals(variables('UserInput'), null),
  equals(variables('UserInput'), '')
)

Better Pattern:

empty(coalesce(variables('UserInput'), ''))

Mathematical Calculations

Pattern 1: Percentage Calculation

Calculate Discount Amount:

mul(variables('OrderTotal'), div(variables('DiscountPercent'), 100))

Example: $1,000 order Ɨ 15% = $150 discount

Final Price:

sub(variables('OrderTotal'), mul(variables('OrderTotal'), div(variables('DiscountPercent'), 100)))

Pattern 2: Rounding

Round to 2 Decimal Places:

div(round(mul(variables('Price'), 100)), 100)

Explanation:

  • mul(variables('Price'), 100) - 15.567 ā†’ 1556.7
  • round(...) - 1556.7 ā†’ 1557
  • div(..., 100) - 1557 ā†’ 15.57

Pattern 3: Min/Max - Boundary Enforcement

Ensure Value is Between 1-100:

min(max(variables('UserInput'), 1), 100)

Explanation:

  • max(variables('UserInput'), 1) - Minimum value is 1
  • min(..., 100) - Maximum value is 100

Performance Optimization Patterns

Rule 1: Avoid Compose Chains - Use Variables

Bad Pattern (5 actions):

Compose1 ā†’ Compose2 ā†’ Compose3 ā†’ Compose4 ā†’ Compose5

Good Pattern (1 variable initialization, reuse):

{
  "Initialize_ProcessedData": {
    "type": "InitializeVariable",
    "inputs": {
      "variables": [
        {
          "name": "ProcessedData",
          "type": "object",
          "value": {
            "field1": "@triggerBody()?['Field1']",
            "field2": "@toUpper(triggerBody()?['Field2'])",
            "field3": "@formatDateTime(utcNow(), 'yyyy-MM-dd')"
          }
        }
      ]
    }
  }
}

Access Later:

variables('ProcessedData')?['field1']

Rule 2: Replace Loops with Select/Filter

Performance Comparison (1,000 items):

Pattern Actions Duration API Calls
Apply to Each loop 1,000 ~100 seconds 1,000
Select expression 1 ~1 second 1

Savings: 99.9% fewer actions, 99% faster

Rule 3: Join Arrays Efficiently

Bad Pattern (String Concatenation in Loop):

Apply to Each ā†’ Append to String Variable

Good Pattern (Join Expression):

join(
  select(variables('Users'), item()?['Email']),
  '; '
)

Expression Debugging Techniques

Technique 1: Compose Actions for Inspection

Problem: Expression returns unexpected value, can't see intermediate results

Solution: Add Compose actions to inspect each step

{
  "Compose_Step1": {
    "type": "Compose",
    "inputs": "@body('Get_items')?['value']"
  },
  "Compose_Step2": {
    "type": "Compose",
    "inputs": "@length(outputs('Compose_Step1'))"
  },
  "Compose_Step3": {
    "type": "Compose",
    "inputs": "@first(outputs('Compose_Step1'))"
  }
}

Review in Flow Run History: Check each Compose output

Technique 2: Peek Code View

Action: Click "Peek Code" in flow designer to see raw JSON

Benefits:

  • See actual expression syntax (not visual representation)
  • Copy/paste expressions
  • Understand data structure

Technique 3: Test Expressions in Isolation

Create Test Flow:

  1. Manual trigger
  2. Initialize variables with sample data
  3. Compose action with expression to test
  4. Run and inspect outputs

Example:

{
  "Initialize_TestData": {
    "type": "InitializeVariable",
    "inputs": {
      "variables": [
        {
          "name": "TestArray",
          "type": "array",
          "value": [
            {"id": 1, "name": "Item1"},
            {"id": 2, "name": "Item2"}
          ]
        }
      ]
    }
  },
  "Test_Expression": {
    "type": "Compose",
    "inputs": "@select(variables('TestArray'), item()?['name'])"
  }
}

Advanced Conditional Logic

Pattern 1: Nested If (Ternary Operator)

Scenario: Assign priority based on amount

if(
  greaterOrEquals(variables('Amount'), 10000),
  'Critical',
  if(
    greaterOrEquals(variables('Amount'), 1000),
    'High',
    if(
      greaterOrEquals(variables('Amount'), 100),
      'Medium',
      'Low'
    )
  )
)

Explanation:

  • Amount ā‰„ $10,000 ā†’ "Critical"
  • Amount ā‰„ $1,000 ā†’ "High"
  • Amount ā‰„ $100 ā†’ "Medium"
  • Otherwise ā†’ "Low"

Pattern 2: Switch-Like Logic with Objects

Scenario: Map department codes to full names

{
  "ENG": "Engineering",
  "SAL": "Sales",
  "MKT": "Marketing",
  "FIN": "Finance"
}[variables('DepartmentCode')]

With Default Fallback:

coalesce(
  {
    "ENG": "Engineering",
    "SAL": "Sales",
    "MKT": "Marketing"
  }[variables('DepartmentCode')],
  'Unknown Department'
)

Real-World Enterprise Use Cases

Use Case 1: Dynamic Approval Routing

Requirement: Route approvals based on amount and department

Expression:

if(
  greaterOrEquals(variables('InvoiceAmount'), 50000),
  variables('CFO_Email'),
  if(
    and(
      greaterOrEquals(variables('InvoiceAmount'), 10000),
      equals(variables('Department'), 'IT')
    ),
    variables('CTO_Email'),
    coalesce(body('Get_Department')?['ManagerEmail'], variables('DefaultApproverEmail'))
  )
)

Logic:

  • Amount ā‰„ $50,000 ā†’ CFO approval
  • Amount ā‰„ $10,000 AND IT Department ā†’ CTO approval
  • Otherwise ā†’ Department Manager (or default if manager not found)

Use Case 2: Generate Unique Reference Number

Requirement: Create unique invoice reference: INV-2025-001234

Expression:

concat(
  'INV-',
  formatDateTime(utcNow(), 'yyyy'),
  '-',
  substring(concat('000000', string(add(variables('LastInvoiceNumber'), 1))), sub(length(concat('000000', string(add(variables('LastInvoiceNumber'), 1)))), 6))
)

Simplified Version with Fixed Length:

concat('INV-', formatDateTime(utcNow(), 'yyyy'), '-', padLeft(string(variables('InvoiceCounter')), 6, '0'))

Note: Power Automate doesn't have native padLeft, use workaround:

substring(concat('000000', string(variables('Counter'))), length(concat('000000', string(variables('Counter')))) - 6)

Use Case 3: Parse Email Address for User Lookup

Requirement: Extract username and domain from email for Azure AD lookup

Extract Username:

substring(variables('Email'), 0, indexOf(variables('Email'), '@'))

Extract Domain:

substring(variables('Email'), add(indexOf(variables('Email'), '@'), 1))

Complete Flow:

{
  "Initialize_Email": {
    "type": "InitializeVariable",
    "inputs": {
      "variables": [
        {
          "name": "EmailAddress",
          "type": "string",
          "value": "john.doe@contoso.com"
        }
      ]
    }
  },
  "Extract_Username": {
    "type": "SetVariable",
    "inputs": {
      "name": "Username",
      "value": "@substring(variables('EmailAddress'), 0, indexOf(variables('EmailAddress'), '@'))"
    }
  },
  "Extract_Domain": {
    "type": "SetVariable",
    "inputs": {
      "name": "Domain",
      "value": "@substring(variables('EmailAddress'), add(indexOf(variables('EmailAddress'), '@'), 1))"
    }
  }
}

Best Practices Summary

DO:

  1. Use Select/Filter for Array Operations - Replace 1,000-action loops with 1-action expressions
  2. Implement Null Safety - Always use ?[] safe navigation and coalesce() for optional fields
  3. Test Expressions in Isolation - Create test flows with sample data before using in production
  4. Document Complex Expressions - Add description in action properties explaining logic
  5. Use Variables for Reusable Values - Initialize once, reference multiple times
  6. Combine Operations When Possible - concat() + toUpper() + trim() in single expression
  7. Prefer Built-In Functions - join() vs manual string concatenation, union() vs deduplication loops
  8. Format Dates Explicitly - Don't rely on default formats, specify yyyy-MM-dd HH:mm:ss
  9. Validate Data Types - Use int(), string(), bool() for type safety
  10. Use Workflow Functions - trigger(), body(), outputs() for accessing action results

DON'T:

  1. Don't Nest Expressions Too Deeply - Max 3-4 levels, break into multiple actions for readability
  2. Don't Hardcode Values - Use variables/parameters for emails, URLs, thresholds
  3. Don't Ignore Null Values - Flows fail silently, always handle nulls with coalesce() or safe navigation
  4. Don't Use Apply to Each for Simple Transformations - Use select() expression instead
  5. Don't Concatenate Strings in Loops - Use join() or concat() with arrays
  6. Don't Skip Expression Testing - Test with edge cases (null, empty, large datasets)
  7. Don't Mix UTC and Local Times - Always convert explicitly with convertTimeZone()
  8. Don't Assume Data Structure - API responses change, use safe navigation
  9. Don't Forget Performance Impact - Expressions are fast, but complex regex or nested loops slow down
  10. Don't Over-Engineer - If visual actions are clearer, use them (expressions aren't always better)

Troubleshooting Guide

Issue 1: Expression Fails with "Unable to process template language expressions"

Symptoms:

  • Flow fails at action with expression
  • Error message: "Unable to process template language expressions in action 'Compose' inputs at line '1' and column '1234': 'The template language function 'body' expects its parameter to be a string'"

Common Causes:

  1. Action name referenced doesn't exist (typo in action name)
  2. Action hasn't run yet (referencing action that comes later)
  3. Action failed (can't access outputs of failed action)

Resolution:

// Bad: Action name has space, typo
body('Get items')

// Good: Action name matches exactly
body('Get_items')

// Check in runAfter dependencies
"runAfter": {
  "Get_items": ["Succeeded"]
}

Issue 2: Null Reference Error - "Property 'Email' Cannot be Selected"

Symptoms:

  • Flow fails when accessing nested property
  • Error: "The template language expression 'triggerBody()['Editor']['Email']' cannot be evaluated because property 'Editor' doesn't exist"

Common Causes:

  1. Property is optional and null for this item
  2. SharePoint Person field not populated
  3. JSON structure different than expected

Resolution:

// Bad: Will fail if Editor is null
triggerBody()['Editor']['Email']

// Good: Safe navigation with fallback
coalesce(triggerBody()?['Editor']?['Email'], 'noemail@contoso.com')

Issue 3: Date Timezone Mismatch

Symptoms:

  • Flow calculates incorrect date (off by hours)
  • SLA deadlines wrong
  • Date comparisons fail

Common Causes:

  1. utcNow() returns UTC, but comparison uses local time
  2. SharePoint dates in local time, comparing to UTC
  3. Timezone not specified in convertTimeZone()

Resolution:

// Bad: Mixing UTC and local time
addDays(utcNow(), 1) vs triggerBody()?['DueDate']  // DueDate might be EST

// Good: Convert both to same timezone
convertTimeZone(utcNow(), 'UTC', 'Eastern Standard Time') vs
convertTimeZone(triggerBody()?['DueDate'], 'Eastern Standard Time', 'Eastern Standard Time')

Issue 4: Expression Returns Unexpected Result

Symptoms:

  • Expression evaluates but result is wrong
  • Array operations produce incorrect output
  • String manipulation doesn't match expected

Diagnosis:

  1. Add Compose actions to inspect intermediate steps
  2. Check data types (int vs string affects comparison)
  3. Review operator precedence (AND/OR evaluation order)

Example - Debug Filter Expression:

{
  "Compose_OriginalArray": {
    "type": "Compose",
    "inputs": "@variables('Items')"
  },
  "Compose_FilterCondition": {
    "type": "Compose",
    "inputs": "@equals(first(variables('Items'))?['Status'], 'Active')"
  },
  "Compose_FilteredArray": {
    "type": "Compose",
    "inputs": "@filter(variables('Items'), equals(item()?['Status'], 'Active'))"
  }
}

Issue 5: Performance Degradation with Large Datasets

Symptoms:

  • Flow times out (>30 minutes)
  • Excessive action consumption (10,000+ actions)
  • HTTP 429 throttling errors

Common Causes:

  1. Using Apply to Each instead of select/filter expressions
  2. Nested loops (O(nĀ²) complexity)
  3. Making API calls inside loops

Resolution:

// Bad: 5,000 items Ɨ 10 actions per item = 50,000 actions
Apply to Each (5,000 items)
  ā†’ Get Manager (HTTP call)
  ā†’ Compose
  ā†’ Condition
  ā†’ Append to Array

// Good: 1 action (select expression)
Select(5,000 items) with inline transformations

Key Takeaways

  1. Expressions Dramatically Reduce Action Count: A single select() expression replaces 1,000-action Apply to Each loops, improving performance by 99% and reducing costs by 99%.

  2. Null Safety is Non-Negotiable: Always use safe navigation (?[]) and coalesce() for optional fields to prevent production failures.

  3. Master the Core Patterns: Select (transform arrays), Filter (conditional extraction), Union (deduplication), Join (array to string), Coalesce (defaults) solve 80% of use cases.

  4. Test Before Production: Create test flows with sample data, use Compose actions to inspect intermediate results, validate edge cases (null, empty, large datasets).

  5. Performance Matters: Every expression vs visual action trade-off affects flow execution time and cost. Inline expressions are faster but less debuggable; find the right balance for your scenario.

Next Steps

  1. Practice with Sample Flows: Create test flows to experiment with select, filter, join, coalesce, formatDateTime
  2. Refactor Existing Flows: Identify Apply to Each loops that can be replaced with select/filter expressions
  3. Build Expression Library: Document your commonly-used expressions for reuse (e.g., email parsing, date formatting)
  4. Review Official Documentation: Bookmark Power Automate Expression Reference for function syntax
  5. Join Community: Microsoft Power Automate Community has extensive expression examples and troubleshooting help

Resources