In a Power Automate array Group By on 1 column and concatenate text in

Hi, you can do it multiple ways.

Solution 1 -

Step 1: Initialize variables

1. Initialize an Array variable
   Name: GroupedArray
   Value: []

2. Initialize a String variable
   Name: AnswerText
   Value: empty

Step 2: Get distinct Titles

Add a Compose action called DistinctTitles and use this expression:

union(
  select(variables('vAnswersArray'), item()?['Title']),
  select(variables('vAnswersArray'), item()?['Title'])
)

This gives you a unique list of Titles.

Step 3: Apply to each Title

Add Apply to each
Input: outputs('DistinctTitles')

Inside the loop:

Step 4: Filter array by Title

Add Filter array
From: variables('vAnswersArray')

Condition:

item()?['Title'] is equal to items('Apply_to_each')

Step 5: Build concatenated Answer text

Add Compose action called CombinedAnswers with this expression:

join(
  select(body('Filter_array'), item()?['Answer']),
  '\n'
)

This joins all matching answers with a new line.

Step 6: Append grouped result

Add Append to array variable
Variable: GroupedArray

Value:

{
  "Title": "@{items('Apply_to_each')}",
  "Answer": "@{outputs('CombinedAnswers')}"
}

Final Output (GroupedArray)

[
  {
    "Title": "AC-01",
    "Answer": "test ac01 a \n test ac01 b"
  },
  {
    "Title": "AC-02",
    "Answer": "test ac02 a"
  },
  {
    "Title": "AC-03",
    "Answer": "test ac03 a \n test ac03 b"
  },
  {
    "Title": "AC-04",
    "Answer": "test ac04 a"
  }
]

Final output with Grouped by Title, Answers concatenated, Index removed, Order preserved based on first occurrence

Solution 2-

Below is the fastest-performance solution in Power Automate.
It is optimized for large arrays, uses one pass over the data, and avoids nested filter() calls (which are slow).

Fastest approach (single-pass dictionary build + projection)

Use ONE Compose action with the expression below.

select(
  keys(outputs('BuildDictionary')),
  {
    'Title': item(),
    'Answer': outputs('BuildDictionary')?[item()]
  }
)

Then add ONE more Compose before it named BuildDictionary:

reduce(
  variables('vAnswersArray'),
  createObject(),
  lambda(
    'acc',
    'cur',
    setProperty(
      acc,
      cur()?['Title'],
      if(
        equals(acc?[cur()?['Title']], null),
        cur()?['Answer'],
        concat(acc?[cur()?['Title']], '\n', cur()?['Answer'])
      )
    )
  )
)

That’s it — two Composes total, no loops, no filters.

Final output

[
  {
    "Title": "AC-01",
    "Answer": "test ac01 a \n test ac01 b"
  },
  {
    "Title": "AC-02",
    "Answer": "test ac02 a"
  },
  {
    "Title": "AC-03",
    "Answer": "test ac03 a \n test ac03 b"
  },
  {
    "Title": "AC-04",
    "Answer": "test ac04 a"
  }
]

Why this is the fastest possible solution

• reduce() loops once over the array (O(n))

• Data is stored in a dictionary (hash lookup, O(1))

• No nested filter() or select() inside loops

• No variables or Apply to each

• Memory efficient and scalable

Thanks.