Solution: AriaNotify Error in Fabric Dataflows

The Error

If you're encountering this error in Fabric Dataflows:

This is caused by how Power Query handles streaming data transformations and triggers UI progress notifications.

Root Cause

The error occurs when performing column transformations on streaming data from API sources (like Dynamics 365 Business Central, Dataverse, REST APIs, etc.).

When you transform columns on streaming data:

1. Data flows incrementally from the API
2. Each chunk triggers UI progress updates
3. The UI's accessibility notification system gets called repeatedly
4. A bug in the FluentUI component tries to set notification priority to "none" (invalid value)
5. The error is thrown and can cause the dataflow to fail

The Solution: Buffer Before Transform

The fix is simple: buffer your data before performing transformations.

❌ Problem Pattern (Causes Error)

let
    Source = Dynamics365BusinessCentral.ApiContentsWithOptions(...),
    Navigation_1 = Source{[Name = "Environment"]}[Data],
    Navigation_2 = Navigation_1{[Name = "Advanced"]}[Data],
    Navigation_3 = Navigation_2{[Name = "api/v2.0"]}[Data],
    Navigation_4 = Navigation_3{[Name = "entities", Signature = "table"]}[Data],

    // ❌ Transforming streaming data - triggers the bug
    #"Changed column type" = Table.TransformColumnTypes(
        Navigation_4,
        {
            {"modifiedAt", type datetime},
            {"createdAt", type datetime},
            {"status", type text}
        }
    ),
    #"Replaced values" = Table.ReplaceValue(
        #"Changed column type",
        "_x0020_",
        " ",
        Replacer.ReplaceText,
        {"status"}
    )
in
    #"Replaced values"

✅ Solution Pattern (Prevents Error)

let
    Source = Dynamics365BusinessCentral.ApiContentsWithOptions(...),
    Navigation_1 = Source{[Name = "Environment"]}[Data],
    Navigation_2 = Navigation_1{[Name = "Advanced"]}[Data],
    Navigation_3 = Navigation_2{[Name = "api/v2.0"]}[Data],
    Navigation_4 = Navigation_3{[Name = "entities", Signature = "table"]}[Data],

    // ✅ Buffer the data FIRST - load completely into memory
    Buffer_Data = Table.Buffer(Navigation_4),

    // ✅ Now transform the buffered data - no streaming, no UI bug
    #"Changed column type" = Table.TransformColumnTypes(
        Buffer_Data,
        {
            {"modifiedAt", type datetime},
            {"createdAt", type datetime},
            {"status", type text}
        }
    ),
    #"Replaced values" = Table.ReplaceValue(
        #"Changed column type",
        "_x0020_",
        " ",
        Replacer.ReplaceText,
        {"status"}
    )
in
    #"Replaced values"

Why This Works

Streaming vs Buffered Execution

Why You Should Buffer Anyway (Beyond Bug Fix)

Even without this bug, buffering before transformations is a best practice for several reasons:

1. Performance Optimization

• Prevents repeated API calls: Without buffering, each downstream operation can trigger re-evaluation and re-fetch from the API
• Faster transformations: Column operations on in-memory data are much faster than streaming operations
• Reduced API throttling: Single API call instead of potential multiple evaluations

2. Predictable Refresh Behavior

• Consistent data snapshots: All transformations work on the same dataset
• Avoid partial refresh issues: No risk of data changing mid-transformation
• Better error handling: Failures are easier to diagnose

3. Lower API Costs

• Some APIs charge per call or have rate limits
• Buffering ensures you only call the API once per refresh
• Prevents accidental duplicate calls from query folding failures

4. Improved Dataflow Stability

• Reduces memory pressure from streaming operations
• More predictable resource usage
• Fewer timeout issues on large datasets

When to Buffer

Best Practice Pattern

Here's a complete best-practice pattern for API-based dataflows:

let
    // 1. Connect to API
    Source = Dynamics365BusinessCentral.ApiContentsWithOptions(
        "PROD",
        null,
        null,
        [UseReadOnlyReplica = true]
    ),

    // 2. Navigate to your table
    Navigation_1 = Source{[Name = "PROD-ENV"]}[Data],
    Navigation_2 = Navigation_1{[Name = "Advanced"]}[Data],
    Navigation_3 = Navigation_2{[Name = "company/v2.0"]}[Data],
    Navigation_4 = Navigation_3{[Name = "glEntries", Signature = "table"]}[Data],

    // 3. Remove unnecessary columns BEFORE buffering (reduces memory)
    Remove_Columns = Table.RemoveColumns(
        Navigation_4,
        {"dimensionValue", "glAccount"},
        MissingField.Ignore
    ),

    // 4. BUFFER - this is the key step
    Buffer_Data = Table.Buffer(Remove_Columns),

    // 5. Now safely perform all transformations
    Format_Columns = Table.TransformColumnTypes(
        Buffer_Data,
        {
            {"documentType", type text},
            {"postingDate", type datetime},
            {"amount", type number}
        },
        "en-US"  // Use locale for date parsing
    ),

    // 6. Additional transformations (replace, merge, etc.)
    Decode_Text = Table.TransformColumns(
        Format_Columns,
        {
            {"documentType", each Text.Replace(_, "_x0020_", " "), type text},
            {"description", each Text.Replace(_, "_x0020_", " "), type text}
        }
    )
in
    Decode_Text

Additional Tips

Optimize Buffer Placement

1. Remove columns first: Buffer after removing unnecessary columns to reduce memory usage
2. Filter early: If possible, filter data before buffering (but after to refresh window for incremental)
3. Buffer once: Don't buffer multiple times in the same query

Example: Incremental Refresh with Buffer

let
    Source = API_Call,
    Navigation = Navigate_To_Table,

    // Filter to incremental window FIRST (query folding)
    Filtered = Table.SelectRows(
        Navigation,
        each [modifiedAt] >= RangeStart and [modifiedAt] < RangeEnd
    ),

    // NOW buffer the filtered data
    Buffer_Data = Table.Buffer(Filtered),

    // Then transform
    Transformed = Table.TransformColumnTypes(Buffer_Data, ...)
in
    Transformed

Summary

References

• Microsoft Docs: Table.Buffer
• Power Query Performance Tips

Tested and verified with Dynamics 365 Business Central API, Dataverse, and REST API sources in Microsoft Fabric.