DEV Community: Muhammad Yasir

Why You Should Use the “Do Until” Loop More Often in Power Automate

Muhammad Yasir — Sun, 23 Feb 2025 08:46:28 +0000

Introduction

Did you know Power Automate has two types of loops, but one is often forgotten ?

Power Automate can execute a set of actions repetitively using loop controls. There are two types of loops in Power Automate: For Each (Apply to Each) and Do Until. However, there are significant differences between them that developers should understand before building a workflow.

Most developers are more familiar with the For Each (Apply to Each) loop because it is simple and requires minimal effort to set up, while Do Until is often overlooked. In this article, we’ll break down when to use each loop to optimize workflow performance and efficiency.

Understanding Loops in Power Automate

1️⃣ For Each (Apply to Each) — Collection-Based Loop

executes actions for each item in a collection (array, list or dataset).

Example Use Case: Sending a reminder to multiple users

Example Scenario:

you have a list user in sharepoints.
you want to remind all users about their training that needs to be finished until a certain period of time.
you read the list in power automate and iterate using For Each loop to send a reminder to each user.

2️⃣ Do Until — Condition-Based Loop

Executes actions until a specific condition is met.

Example Use Case: Fetching Paginated Data from an API Until All Records Are Retrieved.

Example Scenario:

You are working with an API that returns paginated results, meaning only a limited number of records are retrieved per request (e.g., 100 items per page).
you make multiple API requests, increasing the page number each time or update url with next page.
Stop when there are no more pages left.

Key Differences: Do Until vs. For Each

When working with loops in Power Automate, choosing between Do Until and For Each (Apply to Each) depends on your workflow requirements. While both loops help automate repetitive tasks, they serve different purposes and function differently.

When to Use Each?

Developers often use For Each (Apply to Each) by default, regardless of the workflow’s actual needs, while Do Until is often overlooked. However, choosing the right loop can significantly improve efficiency and optimize automation processes. Understanding when to use each loop is essential for building effective workflows.

Use For Each when:

You need to process a predefined collection (emails, records, files, etc.).
The loop should run a fixed number of times based on data count.

Use Do Until when:

The number of iterations is unknown.

You need to wait for a condition to be met (e.g., API response, approval, system update).

Best Practices

For Each: Avoid unnecessary loops by filtering data before processing.
Do Until: Set a timeout or max iteration limit to prevent infinite loops.
Use logging and monitoring to track loop performance.

What’s your experience? Share your thoughts in the comments!

Power Automate Functions (fx): A New Feature for Smarter Workflows

Muhammad Yasir — Sat, 22 Feb 2025 06:36:22 +0000

Introduction
Microsoft Power Automate is an incredible tool for automating workflows across different apps and services. One of its standout features is functions (fx) — these let you manipulate data, perform calculations, and control logic within your flows.

Why Power Automate Functions Are a Game-Changer

✅ Works Everywhere — Use them across Power Automate, Power Apps, and other Microsoft tools for seamless automation.

✅ Reusable — Write once, use anywhere, cutting down redundancy and saving time.

✅ Nested Functions — Stack functions inside each other to create more flexible, modular workflows.

In this guide, we’ll break down some of the most useful Power Automate functions and how they can make your automation smarter and more efficient. Let’s dive in! 🚀

1️⃣ What Are Functions (fx) in Power Automate?

Functions in Power Automate allow users to perform operations on data, including string manipulation, date/time calculations, logical evaluations, and mathematical computations. These functions are similar to Excel formulas and Power Apps expressions.

Power Automate functions are categorized into different types:

**- String Functions (e.g., concat(), substring())

Date and Time Functions (e.g., utcNow(), addDays())
Logical Functions (e.g., if(), equals())
Conversion Functions (e.g., int(), float())
Array Functions (e.g., join(), length())
Workflow Functions (e.g., coalesce(), base64ToString())**

2️⃣ String Functions: Manipulating Text in Power Automate

🔹 concat(text1, text2, …) – Combine Multiple Strings
This function joins multiple text values into a single string.

concat('Hello ', 'Power Automate!')

Output: Hello Power Automate!

🔹 substring(text, start, length) – Extract Part of a String
Extracts a portion of a string based on the start position and length.

substring('PowerAutomate', 0, 5)

Output: Power

🔹 replace(text, oldValue, newValue) – Replace Text in a String
Replaces occurrences of a specified substring within a string.

replace('Welcome to Power Automate', 'Power Automate', 'Flow')

Output: Welcome to Flow

3️⃣ Date and Time Functions: Working with Timestamps

🔹 utcNow() – Get the Current UTC Date and Time

Returns the current timestamp in UTC format.

utcNow()

Output Example: 2024-02-18T10:15:30Z

🔹 addDays(timestamp, days, format?) – Add Days to a Date

addDays(utcNow(), 5, 'yyyy-MM-dd')

Output Example: 2024-02-23

🔹 formatDateTime(timestamp, format) – Format a Date

Formats a date into a specific format.

formatDateTime(utcNow(), 'MM/dd/yyyy')

Output Example: 02/18/2024

4️⃣ Logical Functions: Making Decisions in Flows

🔹 if(condition, valueIfTrue, valueIfFalse) – Conditional Logic

if(equals(10, 10), 'Match', 'No Match')

Output: Match

🔹 equals(value1, value2) – Compare Two Values

equals(5, 10)

Output: false

🔹 coalesce(value1, value2, …) – Return the First Non-Empty Value

coalesce('', 'Power Automate', 'Default')

Output: Power Automate

5️⃣ Array Functions: Handling Lists and Collections

🔹 length(array) – Get the Number of Items in an Array

length(createArray('A', 'B', 'C'))

Output: 3

🔹 join(array, separator) – Convert an Array to a String

join(createArray('A', 'B', 'C'), ', ')

Output: A, B, C

6️⃣ Conversion Functions: Changing Data Types

🔹 int(value) – Convert a String to an Integer

int('100')

Output: 100

🔹 float(value) – Convert a String to a Decimal Number

float('99.99')

Output: 99.99

🔹 string(value) – Convert a Value to Text

string(2024)

Output: '2024'

Test Case

Create Function(fx) in Power Automate Solution to calcualte the last day of the month.
Set parameter, output and Formula.
Perform an unbound action using dataverse and set parameter
Test run

🚀 Next Steps:

Try using functions in your flows.
Explore more Power Automate expressions.
Share your experiences in the comments!
Happy automating! 🤖⚡

Avoid Looping Iterations in Power Automate: Use Filter Array for Efficiency

Muhammad Yasir — Sat, 22 Feb 2025 03:17:06 +0000

Power Automate is a powerful tool for automation, but inefficient flows can slow down performance and increase execution time. A common mistake is overusing Apply to Each (looping iterations) when filtering data. Instead, using the Filter Array action can significantly improve your flow’s efficiency.

Why Avoid Looping in Power Automate?
Using Apply to Each for filtering data:
❌ Slows down execution (loops iterate one-by-one).
❌ Consumes more API calls and runs (impacting Power Automate limits).
❌ Reduces readability and maintainability of your flow.

Using Filter Array instead:
✅ Executes in a single step (faster execution).
✅ Reduces complexity (no need for loops).
✅ Improves flow performance.

Example: Filtering Data Without Loops
Let’s say you have an array of employee records, and you want to filter only employees from the “IT Department”.

Using Apply to Each (Inefficient)
Initialize an empty array variable.
Use Apply to Each to loop through the data.
Add a condition inside the loop (if department = "IT").
Append matching records to the array.
This approach is inefficient because it loops over each item individually.

Using Filter Array (Efficient)
Instead of looping, use the Filter Array action:

Use the Filter Array action to apply a condition (department is equal to IT).
The action automatically returns only the matching results — no looping required!

From these two cases, it is evident that using a loop takes significantly longer to execute (around 4 seconds) compared to using the Filter Array action (around 2 seconds). Now, imagine implementing this in a larger flow — the time difference would increase dramatically.

Therefore, it is crucial to consider using Filter Array whenever possible before building a flow. This approach not only improves efficiency but also reduces execution time and resource consumption.