Microsoft Fabric
Microsoft Fabric Invoke Pipeline Activity: Build Modular and Reusable Data Pipelines
Use the Microsoft Fabric Invoke Pipeline activity to compose parameterized parent and child pipelines across workspaces, with secure connections and practical monitoring.
On this page
A pipeline that ingests, validates, transforms, publishes, notifies and logs everything in one canvas may work at first. As it grows, however, reuse becomes awkward, testing takes longer, the orchestration is harder to read and every edit has a larger blast radius.
The Invoke Pipeline activity gives Fabric pipelines a composition boundary. A parent decides what runs and when; a child owns one focused unit of work. This article builds that pattern with parameters, explains the connection and identity choices, and shows how to monitor the complete run.
What Invoke Pipeline does
Invoke Pipeline is a control-flow activity. It starts another pipeline and can pass values into the target pipeline’s parameters. It belongs to the orchestration layer; which Fabric tool should own each step covers where notebooks, Dataflow Gen2 and Copy jobs fit underneath it.
- Parent / Orchestrator Pipeline
- Invoke Pipeline
- Reusable Child Pipeline
The current activity can target:
- a Fabric pipeline in the same workspace;
- a Fabric pipeline in another workspace;
- an Azure Data Factory pipeline; or
- an Azure Synapse pipeline.
Each activity uses a connection object kept in Fabric’s secure credential store. For a Fabric target, you select a connection, target workspace and target pipeline. For ADF or Synapse, you select that source type, its registered connection and the pipeline name. This is an important difference from simply referencing another item on the same canvas.
Microsoft documents both Invoke Pipeline and Invoke Pipeline (Legacy). The legacy activity can call only Fabric pipelines in the parent’s workspace, and monitoring stops at the parent. The current activity adds cross-workspace and cross-platform targets plus child-pipeline monitoring. New designs should normally use the current activity; keep legacy only where an existing pipeline has a deliberate compatibility reason.
Parent versus child pipeline
Use one small example throughout the design, built in a demo workspace such as Javi Builds Fabric Demo. PL_Sales_Orchestrator is the parent. It invokes PL_Load_Sales_Daily, waits for the result, and only then continues downstream.
- PL_Sales_Orchestrator
- Invoke Pipeline
- PL_Load_Sales_Daily
- Wait for completion
- Continue downstream
The parent owns schedule, environment-wide sequencing and notifications. The child owns validation and idempotent processing for one business date and region. That child can later be reused from a backfill orchestrator, a support rerun or Lab 02 — Parameterized Pipelines and Incremental Processing without duplicating its business logic.
Use these child parameters:
| Parameter | Type | Example | Purpose |
|---|---|---|---|
p_date |
String | 2026-10-19 |
Business date to load |
p_region |
String | US |
Region to process |
Passing the business date explicitly keeps reruns predictable: rerunning 2026-10-19 reloads that date instead of whatever “today” happens to be when the child starts.
Add the current Invoke Pipeline activity
Create PL_Sales_Orchestrator, open the Activities pane, and add the current Invoke Pipeline activity, not Invoke Pipeline (Legacy). Name it Invoke_PL_Load_Sales_Daily and connect it where the reusable load must run, after any preparation steps and before the work that depends on the loaded data.
Configure the target pipeline
Create PL_Load_Sales_Daily in the same demo workspace, or another safe demo workspace when testing cross-workspace invocation. In the Invoke Pipeline settings, set the target type to Fabric, choose a safe connection, select the target workspace when applicable, select PL_Load_Sales_Daily, and leave Wait on completion enabled.
Same-workspace calls keep setup compact. Cross-workspace calls require a supported connection and an identity authorized on the target workspace; the identity choices are covered under production considerations below.
Pass parameters from parent to child
Define p_date and p_region on PL_Load_Sales_Daily. Validate their format and allowed values, map them into the child activity that performs the load, and test the child directly with 2026-10-19 and US before invoking it from the parent.
- Add both child parameters with safe demo defaults.
- Map them into the Notebook, Copy, or Stored Procedure activity that performs the load.
- Validate the date format and region allow-list before writing data.
- Make the load idempotent so a retry converges on the same result.
- Record the child run ID, parameter values, status, and safe row counts in the execution log.
For a notebook child, the mapping might be:
| Notebook base parameter | Dynamic value |
|---|---|
p_date |
@pipeline().parameters.p_date |
p_region |
@pipeline().parameters.p_region |
This keeps the child independently testable before the parent is involved.
Map the parent values
Give PL_Sales_Orchestrator its own p_date and p_region parameters, then map each child parameter in the Invoke Pipeline settings:
| Child parameter | Parent value |
|---|---|
p_date |
@pipeline().parameters.p_date |
p_region |
@pipeline().parameters.p_region |
Dynamic expressions let one parent serve any date and region. A static value such as US is also valid when a parent only ever processes one region, but it hard-codes that decision into the orchestration.
Run the parent with 2026-10-19 and US, verify what the child received, then test one invalid date or region to confirm validation fails safely.
waitOnCompletion changes the dependency contract
With waitOnCompletion set to true—the documented default in the pipeline definition—the Invoke activity remains active until the child finishes. A success dependency after it therefore means “the child succeeded.” Use this for publishing, data-quality gates and notifications that depend on the child’s result.
With it set to false, the parent continues after the child has been submitted. Downstream activities can overlap the child and cannot treat submission as proof that processing completed.
- Invoke child pipeline
- waitOnCompletion = true
- Wait for child result
- Publish or notify
- waitOnCompletion = false
- Continue after submission
- Independent parallel work
Fire-and-continue is useful only when the next work is genuinely independent and another mechanism owns child failure detection. It is not a shortcut for a dependency that still exists.
At definition level, Microsoft currently documents the modern activity type as ExecutePipeline; InvokePipeline is the deprecated definition type. A simplified definition fragment looks like this:
{
"name": "Invoke_PL_Load_Sales_Daily",
"type": "ExecutePipeline",
"typeProperties": {
"pipeline": {
"referenceName": "PL_Load_Sales_Daily",
"type": "PipelineReference"
},
"parameters": {
"p_date": "@pipeline().parameters.p_date",
"p_region": "@pipeline().parameters.p_region"
},
"waitOnCompletion": true
}
}
Treat this as an explanatory fragment, not a portable deployment file: exported definitions can also contain policies, connection references and environment-specific identifiers.
Run and monitor the complete chain
After running the parent, use the canvas Output tab for the immediate execution and Fabric monitoring/run history for investigation. The current Invoke activity lets you navigate into child runs, which is essential when the parent only reports that an invoked step failed.
For a successful run, confirm that PL_Sales_Orchestrator shows the Invoke_PL_Load_Sales_Daily activity, that the PL_Load_Sales_Daily child run received 2026-10-19 and US, and that status and duration look plausible at both levels. For deeper operational guidance, read Monitoring Fabric Pipelines and Notebooks and Designing an Execution Log for Data Pipelines.
Capture these fields in a durable execution log:
- parent and child run IDs;
- parent and child pipeline names;
- target workspace or platform;
- parameter values such as
p_dateandp_region; - start/end timestamps, status and error summary;
- safe row-count or watermark metrics.
Do not log credentials or secrets. Use secure input/output where activity payloads contain sensitive values. A correlation ID passed from parent to child turns a nested run tree into one searchable operation.
Handle child failures
With waitOnCompletion = true, a child failure is relevant to the parent activity because the parent is waiting for the result. Inspect the failed Invoke Pipeline activity first, then open the child run to find the activity and error that caused the failure. Check both levels: the parent explains orchestration context, while the child contains the processing detail.
With waitOnCompletion = false, the parent continues after submission and does not wait for the child’s final outcome. A separate monitoring or alerting path must therefore own child-failure detection. Do not place result-dependent work after a fire-and-continue invocation.
Choose the connection identity deliberately
The Fabric connection for Invoke Pipeline currently offers three authentication kinds:
| Authentication | Good fit | Operational concern |
|---|---|---|
| Organizational account | Interactive development and early testing | Tied to a person; token and access lifecycle can disrupt automation |
| Service principal | Non-interactive automation with centrally managed app identity | Tenant settings, secret/certificate lifecycle and workspace permissions |
| Workspace Identity | Workload identity aligned to the calling Fabric workspace | Must be created in the caller’s workspace and granted target access |
For Workspace Identity, Microsoft currently requires the identity in the same workspace as the calling pipeline, the tenant setting Service principals can call Fabric public APIs, and sufficient access to the target workspace. For a cross-workspace call, grant the caller’s workspace identity access to the target workspace; Microsoft identifies Contributor as sufficient for most scenarios. Apply least privilege and validate the exact permissions in your tenant.
The generic Data Factory Workspace Identity connector list is broader than this Invoke Pipeline scenario. Do not assume that support for an identity on one data-source connection automatically grants permission to invoke a pipeline—the target workspace authorization still matters.
Production patterns and traps
Place the pattern inside a deliberate Microsoft Fabric architecture and promote it with reviewed Fabric Git integration and CI/CD using fabric-cicd. The published end-to-end Fabric sales analytics lab is a useful environment for practicing the surrounding workspace, pipeline, and monitoring workflow with synthetic data.
Keep each child cohesive. “Load one bounded dataset” is a useful child; “do whatever the parent asks” merely moves the monolith. Version parameter contracts carefully: adding an optional parameter is safer than renaming a required one while several parents still call the child.
Avoid deep invocation chains. Parent → child is easy to reason about; parent → child → grandchild → another platform becomes difficult to troubleshoot and can hide ownership. Prefer a shallow orchestrator with focused children.
Other practical rules:
- validate parameters again inside the child;
- pass business time explicitly instead of calculating “today” independently in each child;
- configure retries only for transient, idempotent work;
- test the child directly, then test the parent-child contract;
- keep workspace IDs, connection IDs and identities environment-specific through deployment configuration;
- use
waitOnCompletion = falseonly with explicit asynchronous monitoring.
Fabric versus Azure Data Factory
The orchestration idea will feel familiar to ADF engineers, but the implementation context differs. Fabric uses connection objects rather than ADF linked services and does not use separate dataset artifacts in the same way. Fabric uses Save and Run rather than ADF’s publish flow, integrates with Fabric workspaces and OneLake items, and exposes the modern cross-platform Invoke Pipeline experience. The equivalent ADF control-flow activity is named Execute Pipeline.
Do not assume that an exported ADF activity definition can be pasted unchanged into Fabric. Expressions are largely familiar, but connections, item references, definitions, deployment and monitoring belong to the Fabric model.
Invoking ADF pipelines is also a practical bridge for SSIS packages that must stay on an Azure-SSIS integration runtime for now. Migrate SSIS Packages to Microsoft Fabric covers when that bridge makes sense.
A reusable design checklist
Before promoting the pattern, verify that:
- the child has one clear responsibility;
- its parameter names, types and boundary semantics are documented;
- retries and reruns are idempotent;
- the connection uses an appropriate non-personal identity for production;
- cross-workspace permissions are explicit;
- completion behavior matches downstream dependencies;
- parent and child runs share a correlation value;
- failures are visible in monitoring and durable logs;
- the child can be tested without the parent.
When to use Invoke Pipeline
Use Invoke Pipeline when a unit of work deserves its own boundary:
- the same load is needed by several parents, such as a daily schedule, a backfill and a support rerun;
- the child should be tested, owned or changed independently of the orchestration;
- the work lives in another Fabric workspace, or in Azure Data Factory or Azure Synapse.
Keep activities in one pipeline when they only make sense together and nothing else will call them. A child pipeline adds a parameter contract, a connection and a second run to monitor; that cost is worth paying for reuse and clear ownership, not for every group of activities.
Invoke Pipeline is most valuable as an architecture boundary, not just another canvas activity. A thin parent, stable parameter contract and observable child turn a growing pipeline estate into reusable building blocks.
Next steps
- Monitoring Fabric Pipelines and Notebooks — follow parent and child runs once the pattern is in production.
- Designing an Execution Log for Data Pipelines — record run IDs, parameters and outcomes durably.
- Microsoft Fabric CI/CD with fabric-cicd and Fabric Git integration — promote parent and child pipelines together through environments.
- Microsoft Fabric hub — the full learning path.
Sources and further reading
Was this helpful?
What could be better?
Thanks — that helps me improve Javi Builds.
Continue learning
- Cheat sheetDebug Fabric PipelinesTroubleshoot Microsoft Fabric pipeline failures by isolating the failed activity, separating transient from deterministic errors, validating parameters and identities, and using retries, logging, and controlled reruns safely.Open cheat sheet
- ArticleMicrosoft Fabric Notebook Parameters: Practical Patterns for Reusable PipelinesMake one Fabric notebook serve many runs: the parameters cell, pipeline base parameters, validation, date windows, environments, secrets, safe logging and testing.Read article
What should I build next?
I'm building Javi Builds around practical problems data engineers actually face. Tell me what you'd like to see next.
Stay in the loop
Get the Javi Builds updates you actually care about.
Check your inbox
I sent you a confirmation link. Your subscription will be active after you confirm it.