ExamFinch.com My Study

Study guide

12.3 Low-Code Plug-ins in Dataverse: Automated vs. Instant

Practice this exam

Microsoft Power Platform Functional Consultant PL-200

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Dataverse Tables, Relationships & Core Columns

1.1 Dataverse Table Types, Properties & Ownership 1.2 Table Relationships & Cascading Rules 1.3 Column Types, Formats, Primary Keys & Alternate Keys 1.4 Rollup, Calculated & Formula Columns with Power Fx

2 Chapter 2: Dataverse Data Management & Governance

2.1 Dataverse Search, Quick Find & Relevance Indexing 2.2 Auditing Configuration & Log Management 2.3 Duplicate Detection Rules & Settings 2.4 Bulk Record Operations, Data Import, Export & Templates

3 Chapter 3: Dataverse Security Model & Access Control

3.1 Business Units, Ownership Models & Modern BU Matrix 3.2 Security Roles, Privileges & Depth Levels 3.3 Teams Architecture: Owner, Access, and Microsoft Entra (AAD) Group Teams 3.4 Column-Level Security & Hierarchy Security Models

4 Chapter 4: Model-Driven App Fundamentals & Information Architecture

4.1 Model-Driven App Design, Site Map Navigation & Modern App Designer 4.2 Form Types: Main, Quick Create, Quick View & Card Forms 4.3 View Configuration, System Views, Personal Views & Filters

5 Chapter 5: Advanced Model-Driven App Components & Custom Pages

5.1 Custom Pages & Modern Commanding with Power Fx 5.2 Form Component Controls & Specialized UX Elements 5.3 Embedding Canvas Apps in Model-Driven Forms 5.4 Embedding Power BI Reports, Dashboards & Tiles

6 Chapter 6: Canvas Apps Structure, Formulas & Data Operations

6.1 Canvas App Architecture, Screens, Containers & Controls 6.2 Power Fx Formulas, Delegation & Data Source Limits 6.3 Variables (Context, Global), Collections & State Management 6.4 Triggering Power Automate Cloud Flows from Canvas Apps

7 Chapter 7: Power Pages Site Design, Navigation & Content

7.1 Power Pages Design Studio & Site Structure 7.2 Power Pages Templates, Styling & Responsive Layouts 7.3 Web Pages, Navigation Menus & Content Snippets

8 Chapter 8: Power Pages Data Integration, Forms & Web Roles

8.1 Power Pages Lists, Basic Forms & Advanced Forms 8.2 Table Permissions, Web Roles & Page Access Security 8.3 External Identity Providers & Authentication Configuration

9 Chapter 9: Power Automate Cloud Flow Fundamentals & Triggers

9.1 Cloud Flow Types: Automated, Instant, Scheduled & Desktop Overview 9.2 Dataverse Connector Triggers & Operational Filters 9.3 Standard Connectors, Custom Connectors & Connection References

10 Chapter 10: Cloud Flow Actions, Expressions & Logic Controls

10.1 Logic Controls: Conditions, Switches, Apply to Each & Do Until Loops 10.2 Variables, Data Operations & Dynamic Content Manipulation 10.3 Power Automate Expression Language (WDL / Functions) 10.4 Error Handling, Configure Run After & Scope Controls

11 Chapter 11: Business Process Flows & Guided Processes

11.1 Business Process Flow Architecture, Stages, Steps & Data Steps 11.2 Branching Rules & Multi-Entity Business Process Flows 11.3 BPF Action Steps, Workflows & Cloud Flow Execution 11.4 BPF Security Roles, Order & Process Lifecycle

12 Chapter 12: Classic Workflows, Business Rules & Modern Logic Extensibility

12.1 Classic Dataverse Workflows: Real-Time vs. Background (Async) 12.2 Business Rules: Scope & Actions 12.3 Low-Code Plug-ins in Dataverse: Automated vs. Instant 12.4 Troubleshooting Automations, Run History & Analytics

13 Chapter 13: Power Platform Environment Architecture & Security

13.1 Environment Types: Default, Sandbox, Production, Trial, Developer 13.2 Environment Governance, Groups, Routing & Capacity Management 13.3 Data Loss Prevention (DLP) Policies & Connector Classifications

14 Chapter 14: Application Lifecycle Management (ALM) & Solutions

14.1 Unmanaged vs. Managed Solutions & Solution Layering Mechanics 14.2 Solution Components, Dependencies, Publishers & Prefixes 14.3 Exporting, Importing, Upgrading & Patches 14.4 Solution Checker, App Checker & ALM Best Practices

15 Chapter 15: Enterprise Interoperability & Service Integration

15.1 Exchange / Server-Side Synchronization & Email Integration 15.2 SharePoint & OneDrive Document Management Integration 15.3 Microsoft Word & Excel Document Templates

16 Chapter 16: Copilot, AI Capabilities & Exam Strategy

16.1 Copilot Studio & Generative AI across Power Platform 16.2 AI Builder Prebuilt & Custom Models in Apps and Flows 16.3 PL-200 Exam Strategy, Time Management & Question Analysis

12.3 Low-Code Plug-ins in Dataverse: Automated vs. Instant

Key Takeaways Explain This Topic AI

Low-Code Plug-ins represent modern, high-performance Dataverse server-side business logic authored in Power Fx without requiring compiled C# .NET assemblies.

Automated Plug-ins bind directly to Dataverse table lifecycle events (Create, Update, Delete) and execute synchronously within the database transaction pipeline at Pre-operation or Post-operation stages.

Instant Plug-ins are custom reusable APIs triggered on-demand by Power Apps, Cloud Flows, or external REST endpoints, accepting typed input and output parameters with Entity-bound or Global (unbound) scope.

Low-Code Plug-ins provide strict transactional integrity: invoking the Power Fx 'Error()' function aborts execution and rolls back the entire database transaction.

Low-Code Plug-ins serve as a modern replacement for Classic Real-Time Workflows and basic C# plug-ins, providing sub-millisecond execution and seamless Application Lifecycle Management (ALM) in Dataverse solutions.

Last updated: August 2026

Low-Code Plug-ins in Dataverse: Automated vs. Instant

For enterprise Power Platform deployments, custom server-side business logic has traditionally required professional developers to write, compile, and deploy custom C# assemblies via the Dataverse Plug-in Registration Tool. While pro-code C# plug-ins offer unlimited extensibility, they introduce developer dependencies, complex deployment pipelines, and high maintenance overhead. Low-Code Plug-ins bridge this gap by enabling functional consultants and low-code makers to author high-performance, transactional, server-side logic directly within Dataverse using Power Fx .

1. Low-Code Plug-in Architecture

Low-Code Plug-ins are managed and authored using the Dataverse Accelerator App or directly within modern solution explorers. Instead of compiling .NET code, Dataverse stores Power Fx expressions as metadata and executes them within the sandboxed Dataverse core execution pipeline. +-----------------------------------------------------------------------------------+

  • | LOW-CODE PLUG-IN ARCHITECTURE |
  • | |
  • | +-----------------------------------+ +-----------------------------------+ |
  • | | AUTOMATED PLUG-INS | | INSTANT PLUG-INS | |
  • | | - Bound to Table Events | | - Custom Server-Side API Action | |
  • | | - Triggered by Create/Update/Del | | - Triggered On-Demand via: | |
  • | | - Pre-operation / Post-operation | | * Power Apps (Power Fx) | |
  • | | - Runs inside SQL Transaction | | * Cloud Flows (Perform Action) | |
  • | | - Replaces Real-Time Workflows | | * External REST Web API | |
  • | +-----------------------------------+ +-----------------------------------+ |
  • | | | |
  • | v v |
  • | +-----------------------------------------------------------------------------+ |
  • | | DATAVERSE SERVER-SIDE EXECUTION ENGINE | |
  • | | - Evaluates Power Fx Expressions in-memory (<5ms latency) | |
  • | | - Direct access to ThisRecord, input parameters, and relational queries | |
  • | | - Enforces transactional rollback on Error() exception | |
  • | +-----------------------------------------------------------------------------+ |
  • +-----------------------------------------------------------------------------------+
  • Key Architectural Benefits

Microsecond Latency: Executes in-memory directly on the Dataverse server node, avoiding external HTTP round-trips and connector cold starts.

Transactional Safety: Participates directly in the database transaction; errors automatically trigger a full SQL rollback.

Solution-Aware: Packaged cleanly within unmanaged and managed Dataverse solutions for automated ALM migration across Development, Test, and Production environments.

2. Automated Plug-ins: Table Events & Pipeline Stages

Automated Plug-ins execute automatically in response to specific data manipulation events on a designated Dataverse table. They run synchronously on the server without any user intervention.

Supported Table Events

Create: Fires when a new record is inserted.

Update: Fires when attributes on an existing record are modified.

Delete: Fires when a record is being deleted.

Execution Stages

Automated Plug-ins run in one of two pipeline stages: +-----------------------------------------------------------------------------+

  • | AUTOMATED PLUG-IN EXECUTION STAGES |
  • | |
  • | [PRE-OPERATION (STAGE 20)] |
  • | - Executes BEFORE the database write is committed. |
  • | - Ideal for: Data validation, setting calculated defaults, modifying |
  • | the incoming record attributes via 'ThisRecord'. |
  • | - Best Performance: Avoids redundant database write cycles. |
  • | |
  • | [POST-OPERATION (STAGE 40)] |
  • | - Executes AFTER the primary database write, INSIDE the transaction. |
  • | - Ideal for: Creating child/audit records that require the parent GUID, |
  • | updating secondary related entities. |
  • | - Full Rollback: If post-op fails, primary write is rolled back! |
  • +-----------------------------------------------------------------------------+
  • Power Fx Context & Transactional Rollback with Error()

Within an Automated Plug-in, makers use standard Power Fx formulas. The context variable ThisRecord provides direct access to the record being processed.

To enforce business constraints, makers use the Error() function. When Error() is called, Dataverse immediately halts pipeline execution, rolls back the entire database transaction (reverting all changes made during the request), and returns the custom error message to the caller. // Example: Automated Pre-Operation Plug-in on 'Account' Create/Update

  • If(
  • ThisRecord.CreditLimit > 500000 && IsBlank(ThisRecord.ParentAccount),

Error({ Message: "Accounts with Credit Limit over $500,000 must have a designated Parent Corporate Account." })

  • )
  • 3. Instant Plug-ins: Custom Server-Side Actions

Instant Plug-ins are custom, reusable business operations that execute on-demand. Instead of triggering on a database event, they act as custom server-side endpoints (Custom APIs) that can be invoked from multiple client applications.

Scope: Global (Unbound) vs. Entity-Bound

Global (Unbound): The plug-in is not tied to any specific table row. It performs system-wide calculations, utility operations, or cross-entity validations (e.g., CalculateTaxQuote , VerifyVatNumber ).

Entity-Bound: The plug-in is bound to a specific table row and requires a target record identifier (GUID) upon invocation (e.g., Account.RecalculateCreditScore , Invoice.PostToLedger ).

Parameter Definitions

Instant Plug-ins allow makers to define strongly-typed Input Parameters (arguments passed into the plug-in) and Output Parameters (values returned to the caller):

  • Parameter Data Type Description Supported Direction
  • String Alphanumeric text payload Input & Output
  • Integer / Float / Decimal Numerical values and financial amounts Input & Output
  • Boolean True/False binary flag Input & Output
  • DateTime UTC Date and Time stamp Input & Output
  • EntityReference Reference to a specific Dataverse record (GUID + Table) Input & Output
  • GUID Raw 128-bit identifier Input & Output
  • Invoking Instant Plug-ins +-----------------------------------------------------------------------------+
  • | INVOKING INSTANT PLUG-INS |
  • | |
  • | [1. POWER APPS (CANVAS / CUSTOM PAGES)] |
  • | - Direct Power Fx invocation: |
  • | Set(result, Environment.cr123_CalculateQuote({ LoanAmt: 25000 })); |
  • | |
  • | [2. POWER AUTOMATE CLOUD FLOWS] |
  • | - Dataverse Connector Action: 'Perform an unbound action' OR |
  • | 'Perform a bound action' |
  • | |
  • | [3. EXTERNAL SYSTEMS / WEB API] |
  • | - HTTP POST to Dataverse OData endpoint: |
  • | POST https://org.crm.dynamics.com/api/data/v9.2/cr123_CalculateQuote |
  • +-----------------------------------------------------------------------------+
  • Output Parameter Assignment in Power Fx

In the Instant Plug-in designer, makers specify the Power Fx formula that calculates and returns the output parameter records: // Example: Instant Plug-in returning risk analysis

  • {
  • Approved: InputLoanAmount <= 50000 && InputCreditScore >= 700,
  • CalculatedInterestRate: If(InputCreditScore >= 750, 0.045, 0.065),
  • ResponseMessage: "Credit assessment successfully executed by Dataverse engine."
  • }
  • 4. Technology Comparison: Low-Code Plug-ins vs. Classic Workflows vs. C# Plug-ins

Functional consultants must understand how Low-Code Plug-ins compare to existing extensibility technologies to make informed architectural decisions on the PL-200 exam.

  • Dimension Low-Code Plug-ins Classic Real-Time Workflows Pro-Code C# Plug-ins
  • Authoring Language Power Fx (Low-Code) Legacy Workflow UI (No-Code) C# / .NET (Pro-Code)
  • Execution Latency Ultra-Fast (<5ms) Moderate (~50-100ms) Ultra-Fast (<2ms)
  • Pipeline Stages Pre-op & Post-op Pre-op & Post-op Pre-validation, Pre-op, Post-op
  • Trigger Types Automated (CRUD) & Instant (API) Automated (CRUD) & On-Demand Pipeline Messages (100+ events)

Transactional Rollback Supported ( Error() ) Supported ( Stop: Canceled ) Supported ( InvalidPluginExecutionException )

External REST / SDK Limited (Dataverse scope) None (Dataverse only) Full .NET Network & SDK access

Tooling & ALM Maker Portal / Dataverse Accelerator Legacy Solution Explorer Plug-in Registration Tool, Visual Studio

Ideal Use Case Modern synchronous table logic & reusable custom APIs Legacy maintenance & simple error prompts Complex multi-entity integrations, binary parsing, encryption