Map

The Map node reshapes your data into the structure an output needs. It is the most general Function node: where Formula changes columns and Group By summarizes rows, Map changes the shape of the data itself — including nested structures that flat rows cannot express.

Use Map when you need to:

• Build a nested payload — for example an order record with a lineItems array — for a Response, a write-back, or a Dashboard.
• Place, rename, or compute fields into a specific target structure.
• Summarize a group of rows while keeping the detail rows alongside the summary.

For simple "keep these columns" or "compute this column" needs, Formula is usually enough. Reach for Map when the structure changes.

The target shape

Map always builds toward a target shape — the structure of its output:

• When Map feeds a system that defines its own structure (writing back to an API or OData entity), the target shape comes from that system's schema. You don't invent it — you just bind your data into it.
• When Map is standalone (feeding a Response or a Dashboard), you define the shape yourself.

You then author bindings: for each field in the target shape, you say where its value comes from.

What you can bind

1. Place and compute fields

Bind each output field to:

• a source field as-is,
• a source field under a new name, or
• a computed value written in the shared Expression Language — the same strict-SQL fx language Formula uses (UnitPrice * Quantity, UPPER(Region), COALESCE(Notes, "")).

2. Build nested arrays

Group flat rows into a child array on a parent. Given flat order-line rows, Map can produce one object per order with its lines nested inside:

{
  "orderId": "SO-1001",
  "customer": "Acme",
  "lines": [
    { "sku": "A-1", "qty": 2 },
    { "sku": "B-7", "qty": 5 }
  ]
}

This is the inverse of the Flatten node, which expands nested arrays back into flat rows.

3. Summarize a group

Add a summary field on a parent that aggregates its child group while keeping the child rows — for example a lineCount or orderTotal beside the preserved lines array. This is the key difference from Group By: Group By reduces rows and discards the detail, whereas a Map summary sits alongside the detail it summarizes.

Standalone or inline

Map works in two placements:

• Standalone node on the canvas — feeding a Response, a Dashboard, or acting as a reusable shaping/preview point.
• Inline in a write-back sink — an API or OData entity shapes its own write payload with the same Map binding model, so the structure an external system requires is honored at the point of writing.

Strict mode

Like Formula and Filter, Map exposes a strict mode (Fail on row error). By default a row that fails to map is dropped and recorded as a warning; with strict mode on, the first error halts the run.

Map, Formula, and Group By

Node	Changes	Reduces rows?
Formula	Columns (1:1 per row)	No
Group By	Rolls rows into per-group totals	Yes
Map	The structure / shape (place, nest, summarize)	No (it can nest)

All three author their expressions with the same fx language — Formula and Group By are focused views of what Map can do across the whole shape.

Next steps

• Expression Language — the fx language for computed bindings
• Formula — compute columns without changing structure
• Flatten — expand nested arrays back into flat rows
• Building Flows — put nodes together into a Flow