Study guide
7.4 Azure Functions for Long-Running, Scheduled & Event-Driven Workloads
Microsoft Power Platform Developer Associate PL-400
Track your progress as you read
Finished sections get a check mark.
1 Introduction, Exam Overview & Developer Toolchain
0.1 PL-400 Exam Facts 0.2 Audience Profile & Required Developer Skills 0.3 The Power Platform Developer Toolchain 0.4 Extension-Point Map & AI in the Developer Workflow
2 Create a Technical Design
1.1 Analyzing Technical Architecture and Choosing Out-of-the-Box vs. Custom Solutions 1.2 Designing Authentication, Authorization, and Security Architecture 1.3 Deciding Where Business Logic Runs and Choosing the Right Table Type 1.4 Designing Reusable Power Apps Components and Custom Connectors 1.5 Designing Dataverse Code Components, Automations, and Integrations
3 Build Power Platform Solutions
2.1 Managing Power Platform Environments for Development 2.2 Dataverse Security Roles for Code Components, Least Privilege & Troubleshooting Operational Security 2.3 Solutions, Managing Dependencies & Solution Layers 2.4 Environment Variables & Connection References 2.5 Power Platform Pipelines & CI/CD with Power Platform Build Tools
4 Implement Power Apps Improvements
3.1 Complex Power Fx Formulas and Functions 3.2 Building Reusable Canvas Component Libraries 3.3 Invoking Power Automate Cloud Flows from a Canvas App 3.4 Troubleshooting Canvas and Model-Driven Apps with Monitor and Browser Debugging Tools 3.5 Optimizing Canvas and Model-Driven App Performance
5 Extend the User Experience
4.1 The Client API Object Model & JavaScript Form Scripting 4.2 Event Handler Registration & Navigation to Custom Pages via the Client API 4.3 Client Scripting Against the Dataverse Web API; Command Bar & Buttons with Power Fx and JavaScript 4.4 PCF Fundamentals: The Component Manifest & Lifecycle Events 4.5 Implementing PCF Component Interfaces; Device, Utility & Web API Features 4.6 Packaging, Deploying & Consuming a PCF Component
6 Extend the Platform: Dataverse Plug-ins & Custom APIs
5.1 Plug-in Fundamentals & the Event Execution Pipeline Stages 5.2 Execution Context & Implementing Business Logic in Plug-ins 5.3 Pre/Post Images & Organization Service Operations in Plug-ins 5.4 Registering Plug-ins with the Plug-in Registration Tool & Optimizing Plug-in Performance 5.5 Custom API Messages & Plug-ins That Implement a Custom API 5.6 Configuring Dataverse Business Events
7 Extend the Platform: Custom Connectors
6.1 Open API Definitions: Building and Extending a Custom Connector 6.2 Authentication and Policy Templates for Custom Connectors 6.3 Importing Definitions and Creating Connectors for Azure Services 6.4 Azure Functions in Custom Connectors and Data Transformation
8 Extend the Platform: Platform APIs & Azure Functions
7.1 Dataverse Web API Operations & OAuth Authentication 7.2 Organization Service Operations, Concurrency, Transactions & Bulk Operations 7.3 Service Protection API Limits & Retry Policies 7.4 Azure Functions for Long-Running, Scheduled & Event-Driven Workloads 7.5 Authenticating to Power Platform with Managed Identities
9 Extend the Platform: Power Automate Cloud Flows
8.1 Dataverse connector triggers/actions, trigger filters & retry policies 8.2 Complex expressions & flow control with error handling 8.3 Sensitive input/output parameters & Azure Key Vault 8.4 Reusable child flows & Microsoft Entra ID service principals
10 Develop Integrations
9.1 Publishing Dataverse Events: IServiceEndpointNotificationService & the Plug-in Registration Tool 9.2 Registering Service Endpoints: Webhooks, Azure Service Bus & Event Hub 9.3 Data Synchronization with Change Tracking & Alternate Keys 9.4 Upsert-Based Synchronization with the UpsertRequest Message
11 Exam Readiness & Practice
10.1 Cross-Domain "Where Do I Implement This?" Decision Framework 10.2 Exam-Day Strategy, PL-400 Item Styles & Study Plan
7.4 Azure Functions for Long-Running, Scheduled & Event-Driven Workloads
Key Takeaways Explain This Topic AI
Synchronous Dataverse plug-ins run inside a sandbox with a strict two-minute execution limit; Azure Functions have no such ceiling and suit long-running or compute-heavy work.
A common pattern keeps the plug-in thin — validate, then call an Azure Function via webhook or drop a message on Service Bus for asynchronous processing.
Durable Functions provide orchestration for genuinely long multi-step processes without holding a synchronous connection open.
HTTP triggers suit webhook-style calls from plug-ins or connectors; Timer triggers (NCRONTAB) suit scheduled batch jobs; Service Bus/Event Hub triggers suit consuming published Dataverse events.
The exam tests matching workload execution characteristics (duration, event-driven vs. scheduled, external dependencies) to the right platform component, not defaulting to more plug-in code.
Last updated: July 2026
Not every piece of custom logic belongs inside a Dataverse plug-in. PL-400 expects developers to recognize when a workload has outgrown the plug-in sandbox and should be offloaded to Azure Functions instead, and to choose the right trigger type once it is there.
Why Plug-ins Have a Ceiling
Dataverse plug-ins execute inside a sandboxed, multi-tenant environment that enforces strict resource limits to protect the shared platform. The limit that matters most for this decision: a synchronous plug-in step has a two-minute execution time limit . Asynchronous plug-in steps get more headroom because they run as background system jobs rather than blocking the triggering operation, but they are still subject to sandbox constraints and are not designed for open-ended, long-running, or highly compute-intensive processing.
A plug-in is the right tool when logic is: tightly coupled to a specific Dataverse event, fast (well under the two-minute ceiling), and primarily about validating or shaping data as part of that transaction. An Azure Function is the right tool when logic is: long-running (minutes to hours), scheduled independent of any Dataverse event, dependent on calling multiple external systems, or compute-heavy (image processing, document generation, complex calculations, machine learning inference).
Patterns for Offloading Work
The typical integration pattern keeps the plug-in thin and pushes heavy lifting to Azure:
A lightweight synchronous plug-in validates input and, if valid, quickly calls out — either directly to an Azure Function's HTTP endpoint (a webhook-style call), or by dropping a message onto an Azure Service Bus queue/topic for the Function to pick up asynchronously.
An asynchronous plug-in or a business event registration publishes the event without blocking the user, and an Azure Function subscribed to that channel performs the actual long-running work — completely decoupling the user's save operation from however long the downstream processing takes.
For genuinely long multi-step processes (e.g., a workflow that waits on multiple external systems across minutes or hours), Durable Functions provide an orchestration pattern that can pause and resume without holding a synchronous connection open the whole time.
Choosing an Azure Functions Trigger
Azure Functions supports many trigger types; three come up repeatedly in Power Platform integration scenarios:
Trigger Fires when Typical PL-400 use
HTTP trigger An HTTP request arrives Called synchronously from a plug-in webhook step or a custom connector backed by an Azure service
Timer trigger On a schedule, defined by an NCRONTAB expression Nightly or hourly batch jobs — data cleanup, scheduled synchronization, report generation — with no external caller needed
Service Bus / Event Hub trigger A message lands on a subscribed queue, topic, or event hub Consuming Dataverse events published through the Service Endpoint Registration (Plug-in Registration Tool), enabling fully event-driven, decoupled processing
A scheduled nightly job with no manual trigger is a Timer trigger by definition — reaching for an HTTP trigger there would require something else to call it on a schedule, which is exactly what the Timer trigger already does natively via its NCRONTAB expression.
Why This Distinction Is Exam-Relevant
Scenario questions on this topic typically describe a symptom — a plug-in timing out, a process that needs to run outside business hours, or logic that calls three different external APIs and aggregates the results — and ask where that logic belongs. The correct answer hinges on matching the execution characteristics of the workload (duration, whether it is event-driven or scheduled, and its dependency footprint) to the platform component built for that shape of work, rather than defaulting to "add more code to the existing plug-in." Recognizing the two-minute synchronous plug-in ceiling as the trigger for this decision, and then picking the matching Azure Functions trigger type, is the core skill being tested.
Hosting Plan Affects the Function's Own Time Budget
Once logic has moved to an Azure Function, its own maximum run time still depends on which Azure hosting plan it runs on:
Consumption plan — the default functionTimeout is 5 minutes, and it can be configured up to a 10-minute maximum. This plan scales automatically and is billed per execution, but it is not the right choice for a workload that might legitimately run past 10 minutes.
Premium plan — supports a much longer configurable timeout and keeps instances "warm," avoiding cold-start delay, which matters for latency-sensitive webhook-style calls from a plug-in.
Dedicated (App Service) plan — runs on provisioned VMs the developer already controls, effectively removing the platform-imposed timeout, appropriate for the longest or most resource-intensive orchestration work.
A workload that clearly exceeds the two-minute plug-in ceiling but is still fairly short (a few minutes) fits comfortably on a Consumption plan Function; a workload that could run for tens of minutes or longer needs a Premium or Dedicated plan, or a Durable Functions orchestration that can checkpoint and resume rather than holding one execution open indefinitely.
Keeping the Plug-in Call Itself Fast
Even when a plug-in only kicks off Azure Function work rather than doing the work itself, the call pattern still matters: a synchronous plug-in that calls an Azure Function's HTTP endpoint and waits for a response is still bound by the plug-in's own two-minute ceiling for that wait. If the downstream Function might take longer than a few seconds, the plug-in should hand off the request asynchronously — for example, by dropping a message on a queue and returning immediately — rather than blocking on an HTTP call to a Function that itself might run for minutes.