Home > Docs > Features > Translytical Task Flows

🔄 Translytical Task Flows - Visual Orchestration and Write-Back from Power BI¶

Last Updated: 2026-04-13 | Version: 1.0.0

📑 Table of Contents¶

• 🎯 Overview
• 🏗️ Architecture Overview
• ⚙️ Task Flow Types
• 🔄 Write-Back Patterns
• 🎰 Casino Implementation
• 🏛️ Federal Agency Implementation
• 🔐 Security and Governance
• ⚠️ Limitations
• 📚 References

🎯 Overview¶

Task Flows in Microsoft Fabric (GA March 2026) enable visual orchestration of data tasks triggered directly from Power BI reports. Rather than treating analytics as a read-only activity, Task Flows close the loop between insight and action by allowing business users to write data back from reports, trigger notebook executions, kick off pipeline refreshes, and initiate approval-gated workflows -- all without leaving the Power BI experience.

Write-back is the defining translytical capability: users edit values in a Power BI visual, and those edits flow through a Task Flow into the Lakehouse as Delta table operations. The Lakehouse then cascades downstream refreshes so that dashboards, KPIs, and operational reports reflect the changes within minutes.

Key Capabilities¶

Task Flows vs Data Factory Pipelines¶

📝 Note: Task Flows complement Data Factory pipelines -- they do not replace them. Use Data Factory for scheduled ETL/ELT workloads and Task Flows for interactive, report-driven operational tasks. The two can interoperate: a Task Flow can trigger a Data Factory pipeline as one of its steps.

🏗️ Architecture Overview¶

Task Flows operate as a lightweight orchestration layer between Power BI reports and Fabric compute/storage services. When a user interacts with a Task Flow trigger in a report, the Task Flow engine executes the defined steps in sequence, routing data through notebooks, pipelines, and dataflows before refreshing the downstream semantic model.

End-to-End Architecture¶

flowchart LR
    subgraph PBI["📊 Power BI Report"]
        USER["👤 User Interaction"]
        BTN["🔘 Task Flow Button"]
        WB["✏️ Write-Back Visual"]
    end

    subgraph TaskFlow["🔄 Task Flow Engine"]
        TRIG["⚡ Trigger<br/>Manual / Schedule / Event"]
        APPROVE["✅ Approval Gate<br/>(Optional)"]
        EXEC["⚙️ Task Executor"]
    end

    subgraph Compute["💻 Compute"]
        NB["📓 Notebook<br/>Spark Job"]
        PIPE["🔧 Data Factory<br/>Pipeline"]
        DFLOW["🔄 Dataflow<br/>Gen2"]
    end

    subgraph Storage["💾 Storage"]
        LH["🏠 Lakehouse<br/>Delta Tables"]
        WH["🏢 Warehouse<br/>SQL Tables"]
    end

    subgraph Refresh["📊 Refresh"]
        SM["📊 Semantic Model<br/>Direct Lake Refresh"]
        RPT["📈 Updated Report<br/>Reflects Changes"]
    end

    PBI --> TaskFlow
    USER --> BTN --> TRIG
    USER --> WB --> TRIG
    TRIG --> APPROVE --> EXEC
    EXEC --> Compute
    NB --> Storage
    PIPE --> Storage
    DFLOW --> Storage
    Storage --> SM --> RPT

    style PBI fill:#27AE60,stroke:#1E8449,color:#fff
    style TaskFlow fill:#6C3483,stroke:#4A235A,color:#fff
    style Compute fill:#E67E22,stroke:#CA6F1E,color:#fff
    style Storage fill:#2471A3,stroke:#1A5276,color:#fff
    style Refresh fill:#27AE60,stroke:#1E8449,color:#fff

Data Flow Sequence¶

sequenceDiagram
    participant User as Report User
    participant PBI as Power BI
    participant TF as Task Flow Engine
    participant Gate as Approval Gate
    participant NB as Notebook / Pipeline
    participant LH as Lakehouse
    participant SM as Semantic Model
    participant RPT as Report

    User->>PBI: Edit values in write-back visual
    User->>PBI: Click "Submit Changes" button
    PBI->>TF: Trigger Task Flow with parameters
    TF->>TF: Validate user permissions
    alt Approval required
        TF->>Gate: Send approval request
        Gate->>Gate: Wait for manager approval
        Gate->>TF: Approved / Rejected
    end
    TF->>NB: Execute notebook with write-back payload
    NB->>LH: Merge changes into Delta table
    LH->>SM: Trigger semantic model refresh
    SM->>RPT: Report reflects updated data
    RPT->>User: See changes in dashboard

    Note over NB,LH: Delta MERGE for upsert semantics
    Note over SM,RPT: Direct Lake auto-refresh (< 2 min)

Component Details¶

⚙️ Task Flow Types¶

Type 1: Write-Back Task Flow¶

Users edit values directly in a Power BI table/matrix visual and submit changes. The Task Flow writes the edits to a Delta table and refreshes the report.

Trigger: User clicks "Submit" in write-back visual
  → Validate changed rows (schema, permissions)
  → [Optional] Approval gate
  → Execute notebook: Delta MERGE into target table
  → Refresh semantic model
  → Report updates with new values

Type 2: Scheduled Refresh Task Flow¶

Automate recurring data preparation tasks triggered on a schedule with optional conditional logic.

Trigger: Cron schedule (e.g., daily at 06:00 UTC)
  → Execute dataflow: Refresh staging tables
  → Execute notebook: Run Silver-to-Gold transformations
  → Refresh semantic model
  → Send completion notification

Type 3: Event-Triggered Task Flow¶

React to data events such as new file arrival in OneLake or a threshold breach detected by Data Activator.

Trigger: New file in OneLake path /bronze/daily_feed/
  → Execute pipeline: Ingest and validate new file
  → Execute notebook: Bronze-to-Silver transformation
  → Execute notebook: Silver-to-Gold aggregation
  → Refresh semantic model
  → Alert users via Teams

Type 4: Approval-Gated Task Flow¶

Critical data modifications require manager approval before execution.

Trigger: User submits budget adjustment in Power BI
  → Validate proposed changes against business rules
  → Send approval request to manager (Teams notification)
  → [Wait for approval]
  → If approved: Execute write-back to budget table
  → Refresh semantic model
  → If rejected: Notify submitter with rejection reason

Task Flow Comparison¶

🔄 Write-Back Patterns¶

Pattern 1: Direct Cell Edit¶

Users directly modify values in a Power BI table or matrix visual. The write-back adapter captures changed cells and sends them to the Task Flow.

Write-Back Configuration¶

{
    "task_flow_name": "casino-hold-pct-adjustment",
    "trigger": {
        "type": "write_back",
        "visual_id": "tbl_slot_config",
        "editable_columns": ["target_hold_pct", "status", "notes"],
        "read_only_columns": ["machine_id", "game_title", "current_hold_pct"],
        "submit_button_label": "Submit Configuration Changes"
    },
    "validation": {
        "rules": [
            {
                "column": "target_hold_pct",
                "type": "range",
                "min": 2.0,
                "max": 15.0,
                "message": "Hold percentage must be between 2% and 15%"
            },
            {
                "column": "status",
                "type": "enum",
                "values": ["active", "maintenance", "disabled"],
                "message": "Status must be active, maintenance, or disabled"
            }
        ]
    },
    "approval": {
        "required": true,
        "approvers": ["floor-managers@casino.com"],
        "timeout_hours": 24,
        "auto_reject_on_timeout": true
    },
    "execution": {
        "type": "notebook",
        "notebook_path": "notebooks/gold/write_back_slot_config.py",
        "target_table": "lh_gold.gold_slot_configuration",
        "merge_key": "machine_id",
        "conflict_resolution": "last_writer_wins"
    },
    "post_execution": {
        "refresh_semantic_model": "sm_casino_operations",
        "notification": {
            "teams_channel": "casino-ops",
            "message_template": "{user} updated {row_count} slot machine configurations"
        }
    }
}

Pattern 2: Delta MERGE for Write-Back¶

The notebook executed by the Task Flow receives the write-back payload and applies it using Delta MERGE:

# Databricks notebook source
# COMMAND ----------
# MAGIC %md
# MAGIC ## Write-Back: Slot Configuration Update
# MAGIC Apply user edits from Power BI to the Gold configuration table.

# COMMAND ----------

from pyspark.sql import SparkSession
from pyspark.sql.functions import col, lit, current_timestamp
from delta.tables import DeltaTable

spark = SparkSession.builder.getOrCreate()

# Task Flow passes the write-back payload as a widget parameter
import json
write_back_payload = json.loads(dbutils.widgets.get("write_back_payload"))

# Payload structure:
# {
#     "user": "john.smith@casino.com",
#     "timestamp": "2026-04-13T14:30:00Z",
#     "changes": [
#         {"machine_id": "SL-4421", "target_hold_pct": 8.5, "status": "active", "notes": "Adjusted for weekend"},
#         {"machine_id": "SL-4422", "target_hold_pct": 6.2, "status": "maintenance", "notes": "Pending repair"}
#     ]
# }

# COMMAND ----------

# Convert changes to DataFrame
changes_df = spark.createDataFrame(write_back_payload["changes"])
changes_df = changes_df.withColumn("updated_by", lit(write_back_payload["user"]))
changes_df = changes_df.withColumn("updated_at", current_timestamp())

# COMMAND ----------

# Apply MERGE to Gold table
target = DeltaTable.forName(spark, "lh_gold.gold_slot_configuration")

target.alias("target").merge(
    changes_df.alias("source"),
    "target.machine_id = source.machine_id"
).whenMatchedUpdate(
    set={
        "target_hold_pct": "source.target_hold_pct",
        "status": "source.status",
        "notes": "source.notes",
        "updated_by": "source.updated_by",
        "updated_at": "source.updated_at"
    }
).execute()

# COMMAND ----------

# Log the audit trail
audit_df = spark.createDataFrame([{
    "operation": "write_back",
    "source": "task_flow:casino-hold-pct-adjustment",
    "user": write_back_payload["user"],
    "timestamp": write_back_payload["timestamp"],
    "row_count": len(write_back_payload["changes"]),
    "table": "lh_gold.gold_slot_configuration",
    "details": json.dumps(write_back_payload["changes"])
}])

audit_df.write.format("delta").mode("append").saveAsTable("lh_gold.gold_audit_log")

print(f"Write-back complete: {len(write_back_payload['changes'])} rows updated by {write_back_payload['user']}")

Concurrency and Conflict Resolution¶

When multiple users submit write-back changes simultaneously, the Task Flow engine handles conflicts based on the configured resolution strategy:

flowchart TB
    subgraph Users["👥 Concurrent Users"]
        U1["User A<br/>Edits SL-4421<br/>hold_pct=8.5"]
        U2["User B<br/>Edits SL-4421<br/>hold_pct=9.0"]
    end

    subgraph Resolution["⚖️ Conflict Resolution"]
        LWW["Last Writer Wins<br/>Result: 9.0"]
        FWW["First Writer Wins<br/>Result: 8.5<br/>User B rejected"]
        MF["Merge Fields<br/>If different columns: both applied"]
    end

    subgraph Result["✅ Delta Table"]
        FINAL["SL-4421<br/>Final State"]
    end

    Users --> Resolution --> Result

    style Users fill:#27AE60,stroke:#1E8449,color:#fff
    style Resolution fill:#6C3483,stroke:#4A235A,color:#fff
    style Result fill:#2471A3,stroke:#1A5276,color:#fff

Cascading Refresh Flow¶

After write-back completes, the Task Flow triggers a cascading refresh to ensure all downstream consumers reflect the changes:

flowchart TB
    subgraph WriteBack["✏️ Write-Back"]
        WB["Delta MERGE<br/>Gold Table Updated"]
    end

    subgraph Cascade["🔄 Cascading Refresh"]
        SM["📊 Semantic Model<br/>Direct Lake Refresh"]
        DASH["📈 Operations Dashboard"]
        KPI["📊 KPI Scorecard"]
        ALERT["🔔 Data Activator<br/>Threshold Check"]
    end

    subgraph Downstream["📋 Downstream"]
        RPT1["Executive Summary"]
        RPT2["Floor Manager View"]
        NOTIF["Teams Notification"]
    end

    WB --> SM
    SM --> DASH
    SM --> KPI
    SM --> ALERT
    DASH --> RPT1
    KPI --> RPT2
    ALERT --> NOTIF

    style WriteBack fill:#E67E22,stroke:#CA6F1E,color:#fff
    style Cascade fill:#6C3483,stroke:#4A235A,color:#fff
    style Downstream fill:#27AE60,stroke:#1E8449,color:#fff

🎰 Casino Implementation¶

Use Case: Floor Manager Hold% Adjustment¶

Floor managers adjust target hold percentages for slot machines using a Power BI form, triggering a Task Flow that updates the configuration table, runs a Spark job to propagate settings, and refreshes the operations dashboard.

End-to-End Flow¶

flowchart TB
    subgraph PBI["📊 Power BI: Slot Config Manager"]
        TBL["📋 Editable Table<br/>Machine ID | Game | Current Hold% | Target Hold%"]
        BTN["🔘 Submit Changes"]
        SLC["🔽 Floor Filter | Zone Filter"]
    end

    subgraph TaskFlow["🔄 Task Flow"]
        VAL["✅ Validate<br/>Hold% range: 2-15%"]
        APR["👤 Approval Gate<br/>Floor Manager Sign-off"]
        NB["📓 Notebook<br/>Delta MERGE + Propagation"]
    end

    subgraph Data["💾 Data Layer"]
        CFG["🏠 gold_slot_configuration<br/>Target settings"]
        PROP["🏠 gold_slot_propagation<br/>Applied settings"]
        AUDIT["🏠 gold_audit_log<br/>Change history"]
    end

    subgraph Refresh["📊 Result"]
        SM["Semantic Model Refresh"]
        DASH["📈 Operations Dashboard<br/>Updated Hold% Visible"]
        TEAMS["💬 Teams Notification"]
    end

    PBI --> TaskFlow
    TBL --> BTN --> VAL --> APR --> NB
    NB --> Data
    CFG --> SM --> DASH
    NB --> AUDIT
    NB --> TEAMS

    style PBI fill:#27AE60,stroke:#1E8449,color:#fff
    style TaskFlow fill:#6C3483,stroke:#4A235A,color:#fff
    style Data fill:#2471A3,stroke:#1A5276,color:#fff
    style Refresh fill:#E67E22,stroke:#CA6F1E,color:#fff

Configuration¶

# Databricks notebook source
# COMMAND ----------
# MAGIC %md
# MAGIC ## Casino Hold% Adjustment Task Flow
# MAGIC Propagate hold% configuration changes to downstream systems.

# COMMAND ----------

from pyspark.sql import SparkSession
from pyspark.sql.functions import col, lit, current_timestamp, when
from delta.tables import DeltaTable
import json

spark = SparkSession.builder.getOrCreate()

# Receive write-back payload from Task Flow
payload = json.loads(dbutils.widgets.get("write_back_payload"))

# COMMAND ----------
# MAGIC %md
# MAGIC ### Step 1: Apply Configuration Changes

# COMMAND ----------

changes_df = spark.createDataFrame(payload["changes"])
changes_df = (changes_df
    .withColumn("updated_by", lit(payload["user"]))
    .withColumn("updated_at", current_timestamp())
    .withColumn("approval_status", lit("approved"))
    .withColumn("effective_date", current_timestamp())
)

# Merge into configuration table
config_table = DeltaTable.forName(spark, "lh_gold.gold_slot_configuration")

config_table.alias("t").merge(
    changes_df.alias("s"),
    "t.machine_id = s.machine_id"
).whenMatchedUpdate(
    set={
        "target_hold_pct": "s.target_hold_pct",
        "status": "s.status",
        "notes": "s.notes",
        "updated_by": "s.updated_by",
        "updated_at": "s.updated_at",
        "approval_status": "s.approval_status",
        "effective_date": "s.effective_date"
    }
).execute()

# COMMAND ----------
# MAGIC %md
# MAGIC ### Step 2: Propagate to Operational Systems

# COMMAND ----------

# Generate propagation records for the gaming system interface
propagation_df = (
    spark.read.table("lh_gold.gold_slot_configuration")
    .filter(col("machine_id").isin([c["machine_id"] for c in payload["changes"]]))
    .select(
        "machine_id", "target_hold_pct", "status",
        "effective_date", "updated_by"
    )
    .withColumn("propagation_status", lit("pending"))
    .withColumn("propagation_timestamp", current_timestamp())
)

propagation_df.write.format("delta").mode("append").saveAsTable("lh_gold.gold_slot_propagation")

# COMMAND ----------
# MAGIC %md
# MAGIC ### Step 3: Audit Trail

# COMMAND ----------

audit_records = [{
    "operation": "hold_pct_adjustment",
    "user": payload["user"],
    "timestamp": payload["timestamp"],
    "row_count": len(payload["changes"]),
    "table": "lh_gold.gold_slot_configuration",
    "changes_summary": json.dumps([
        {"machine_id": c["machine_id"], "new_hold_pct": c["target_hold_pct"]}
        for c in payload["changes"]
    ])
}]

spark.createDataFrame(audit_records).write.format("delta").mode("append").saveAsTable("lh_gold.gold_audit_log")

print(f"Hold% adjustment complete: {len(payload['changes'])} machines updated")

Compliance Notes¶

🏛️ Federal Agency Implementation¶

🌾 USDA: Field Inspector Crop Data Update¶

USDA field inspectors use Power BI Mobile to update crop condition assessments during field visits. Changes flow through a Task Flow into the Silver layer, trigger Gold aggregation, and refresh national dashboards.

End-to-End Flow¶

flowchart TB
    subgraph Mobile["📱 Power BI Mobile"]
        INSP["👤 Field Inspector"]
        FORM["📋 Crop Assessment Form<br/>County | Crop | Condition | Yield Est."]
        SUBMIT["🔘 Submit Assessment"]
    end

    subgraph TaskFlow["🔄 Task Flow"]
        VALIDATE["✅ Validate<br/>Condition: Excellent/Good/Fair/Poor/VP"]
        GEO["🌍 Geo-Verify<br/>GPS within assigned county"]
        NB["📓 Notebook<br/>Merge to Silver + Gold Refresh"]
    end

    subgraph Data["💾 Data Layer"]
        SILVER["🏠 silver_usda_crop_conditions<br/>Validated assessments"]
        GOLD["🏠 gold_usda_crop_summary<br/>National aggregation"]
        AUDIT["🏠 gold_audit_log"]
    end

    subgraph Output["📊 Output"]
        SM["Semantic Model"]
        NATL["📈 National Crop Dashboard"]
        WASDE["📋 WASDE Report Input"]
    end

    Mobile --> TaskFlow
    INSP --> FORM --> SUBMIT --> VALIDATE --> GEO --> NB
    NB --> Data
    SILVER --> GOLD --> SM --> Output
    NB --> AUDIT

    style Mobile fill:#27AE60,stroke:#1E8449,color:#fff
    style TaskFlow fill:#6C3483,stroke:#4A235A,color:#fff
    style Data fill:#2471A3,stroke:#1A5276,color:#fff
    style Output fill:#E67E22,stroke:#CA6F1E,color:#fff

Write-Back Notebook¶

# Databricks notebook source
# COMMAND ----------
# MAGIC %md
# MAGIC ## USDA Crop Condition Write-Back
# MAGIC Apply field inspector assessments from Power BI Mobile to the Silver layer.

# COMMAND ----------

from pyspark.sql import SparkSession
from pyspark.sql.functions import col, lit, current_timestamp, to_date
from delta.tables import DeltaTable
import json

spark = SparkSession.builder.getOrCreate()

payload = json.loads(dbutils.widgets.get("write_back_payload"))

# COMMAND ----------
# MAGIC %md
# MAGIC ### Validate and Apply Crop Assessments

# COMMAND ----------

# Valid condition ratings per USDA NASS standards
VALID_CONDITIONS = ["Excellent", "Good", "Fair", "Poor", "Very Poor"]

assessments = []
for record in payload["changes"]:
    if record["crop_condition"] not in VALID_CONDITIONS:
        raise ValueError(f"Invalid condition: {record['crop_condition']}. Must be one of {VALID_CONDITIONS}")
    assessments.append(record)

assessment_df = spark.createDataFrame(assessments)
assessment_df = (assessment_df
    .withColumn("inspector_id", lit(payload["user"]))
    .withColumn("assessment_timestamp", current_timestamp())
    .withColumn("assessment_date", to_date(current_timestamp()))
    .withColumn("data_source", lit("field_inspection"))
)

# COMMAND ----------

# Merge into Silver layer
silver_table = DeltaTable.forName(spark, "lh_silver.silver_usda_crop_conditions")

silver_table.alias("t").merge(
    assessment_df.alias("s"),
    "t.state_code = s.state_code AND t.county_code = s.county_code AND t.crop_type = s.crop_type AND t.assessment_date = s.assessment_date"
).whenMatchedUpdate(
    set={
        "crop_condition": "s.crop_condition",
        "yield_estimate_bu_acre": "s.yield_estimate_bu_acre",
        "moisture_pct": "s.moisture_pct",
        "inspector_id": "s.inspector_id",
        "assessment_timestamp": "s.assessment_timestamp",
        "data_source": "s.data_source"
    }
).whenNotMatchedInsertAll().execute()

# COMMAND ----------
# MAGIC %md
# MAGIC ### Refresh Gold Aggregation

# COMMAND ----------

# Recalculate national crop summary
national_summary = spark.sql("""
    SELECT
        crop_type,
        assessment_date,
        COUNT(*) AS county_count,
        SUM(CASE WHEN crop_condition = 'Excellent' THEN 1 ELSE 0 END) AS excellent_count,
        SUM(CASE WHEN crop_condition = 'Good' THEN 1 ELSE 0 END) AS good_count,
        SUM(CASE WHEN crop_condition = 'Fair' THEN 1 ELSE 0 END) AS fair_count,
        SUM(CASE WHEN crop_condition = 'Poor' THEN 1 ELSE 0 END) AS poor_count,
        SUM(CASE WHEN crop_condition = 'Very Poor' THEN 1 ELSE 0 END) AS very_poor_count,
        AVG(yield_estimate_bu_acre) AS avg_yield_estimate,
        ROUND(
            (SUM(CASE WHEN crop_condition IN ('Excellent', 'Good') THEN 1 ELSE 0 END) * 100.0) / COUNT(*),
            1
        ) AS good_excellent_pct
    FROM lh_silver.silver_usda_crop_conditions
    WHERE assessment_date >= DATEADD(DAY, -7, CURRENT_DATE())
    GROUP BY crop_type, assessment_date
""")

national_summary.write.format("delta").mode("overwrite").saveAsTable("lh_gold.gold_usda_crop_summary")

print(f"Crop assessment write-back complete: {len(payload['changes'])} counties updated")

Additional Federal Use Cases¶

NOAA Station Metadata Task Flow¶

# Databricks notebook source
# COMMAND ----------
# MAGIC %md
# MAGIC ## NOAA Station Calibration Write-Back
# MAGIC Update weather station metadata after field calibration.

# COMMAND ----------

from pyspark.sql import SparkSession
from pyspark.sql.functions import col, lit, current_timestamp
from delta.tables import DeltaTable
import json

spark = SparkSession.builder.getOrCreate()
payload = json.loads(dbutils.widgets.get("write_back_payload"))

# COMMAND ----------

calibration_df = spark.createDataFrame(payload["changes"])
calibration_df = (calibration_df
    .withColumn("calibrated_by", lit(payload["user"]))
    .withColumn("calibration_date", current_timestamp())
    .withColumn("calibration_source", lit("field_inspection"))
)

# Merge calibration data
station_meta = DeltaTable.forName(spark, "lh_silver.silver_noaa_station_metadata")

station_meta.alias("t").merge(
    calibration_df.alias("s"),
    "t.station_id = s.station_id"
).whenMatchedUpdate(
    set={
        "elevation_m": "s.elevation_m",
        "sensor_type": "s.sensor_type",
        "last_calibration_date": "s.calibration_date",
        "calibrated_by": "s.calibrated_by",
        "calibration_notes": "s.calibration_notes",
        "operational_status": "s.operational_status"
    }
).execute()

print(f"Station calibration write-back complete: {len(payload['changes'])} stations updated")

🔐 Security and Governance¶

Write-Back Permissions Model¶

Task Flow write-back operations are governed by a layered permission model that ensures only authorized users can modify data:

Audit Trail Schema¶

Every Task Flow execution generates an audit record:

{
    "audit_id": "aud-2026-04-13-001",
    "task_flow_name": "casino-hold-pct-adjustment",
    "trigger_type": "write_back",
    "triggered_by": "john.smith@casino.com",
    "triggered_at": "2026-04-13T14:30:00Z",
    "approval": {
        "required": true,
        "approver": "jane.manager@casino.com",
        "approved_at": "2026-04-13T14:35:00Z",
        "decision": "approved"
    },
    "execution": {
        "notebook": "notebooks/gold/write_back_slot_config.py",
        "status": "succeeded",
        "duration_seconds": 12,
        "rows_affected": 3
    },
    "changes": [
        {
            "machine_id": "SL-4421",
            "column": "target_hold_pct",
            "old_value": "7.5",
            "new_value": "8.5"
        }
    ],
    "post_execution": {
        "semantic_model_refresh": "succeeded",
        "notification_sent": true
    }
}

Security Best Practices¶

⚠️ Warning: Write-back modifies production Gold layer data. Misconfigured permissions or missing validation rules can lead to data integrity issues. Always test Task Flows in a non-production workspace before deploying to production.

⚠️ Limitations¶

Write-Back Limitations¶

Task Flow Limitations¶

What is Not Supported¶

📝 Note: Task Flows reached GA in March 2026, but write-back capabilities continue to expand. Check the Fabric release notes for the latest supported visual types, column types, and capacity limits. Some limitations listed here may be resolved in subsequent monthly releases.

📚 References¶

🔗 Related Documents¶

• Fabric IQ -- Natural language querying that works alongside Task Flow-modified data
• Real-Time Intelligence -- Event-triggered Task Flows from RTI alerts
• Data Agents -- AI agents that can invoke Task Flows programmatically
• Data Mesh Enterprise Patterns -- Cross-domain write-back governance
• Digital Twin Builder -- Write-back for twin configuration updates
• Architecture -- System architecture overview

📝 Document Metadata - Author: Documentation Team - Reviewers: Power BI, Data Engineering, Compliance, Federal Programs - Classification: Internal - Next Review: 2026-07-13