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

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):

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.