C#

The Life of a Consultant: A Case for Custom Dataverse Plugins

Adam Petkovsky

Adam Petkovsky

— 2 min read
The Life of a Consultant: A Case for Custom Dataverse Plugins
Photo by Clint Patterson / Unsplash

As a consultant, you live by a simple rule: solve problems efficiently and elegantly. You’ve built Model-Driven Apps, automated workflows with Power Automate, and even tweaked UI elements with JavaScript. But sometimes, the standard tools don’t cut it. You need something more powerful—something that works behind the scenes without user interaction. Enter: Custom Dataverse Plugins.

Dataverse plugins are C# classes that run inside the Dataverse event pipeline, allowing you to inject custom logic when records are created, updated, or deleted. They’re fast, efficient, and a must-have tool for extending Power Platform applications beyond out-of-the-box functionality.

Why Consultants Love Plugins

  1. Synchronous Execution – Immediate processing of business logic when a record is modified.
  2. Performance & Efficiency – Runs directly within Dataverse, reducing API calls and improving response times.
  3. Security & Compliance – Executes with system-level security, ensuring consistency.
  4. Complex Business Logic – Supports advanced calculations, integrations, and validations.

For consultants, the real benefit is the ability to enforce business rules at the core, ensuring that no matter who uses the system, data integrity and efficiency are maintained.

Plugin Lifecycle: From Client Request to Deployment

  1. Understand the Business Need – Identify the gaps that out-of-the-box functionality can’t cover.
  2. Develop a C# Plugin – Code the logic using the Dataverse SDK.
  3. Register the Plugin – Deploy it to Dataverse using the Plugin Registration Tool.
  4. Configure Execution – Define trigger conditions and execution order.
  5. Test & Deploy – Validate the behavior before pushing to production.

Step-by-Step: Delivering a Custom Plugin Solution

1. Set Up Your Development Environment

  • Install Visual Studio.
  • Add the Microsoft.CrmSdk.CoreAssemblies NuGet package.
  • Create a new C# Class Library project.

2. Write the Plugin Code

Here’s a basic example of a plugin that runs on record creation including exception handling using try-catch. This ensures the plugin doesn’t break execution if an error occurs

using System;
using Microsoft.Xrm.Sdk;

public class UpdateDescriptionOnCreate : IPlugin
{
    public void Execute(IServiceProvider serviceProvider)
    {
        // Obtain the execution context from the service provider.
        IPluginExecutionContext context = (IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext));

        // Get tracing service to log errors
        ITracingService tracingService = (ITracingService)serviceProvider.GetService(typeof(ITracingService));

        try
        {
            // Ensure that the plugin runs on Create operation
            if (context.MessageName.ToLower() != "create")
                return;

            // Get the entity from input parameters
            if (context.InputParameters.Contains("Target") && context.InputParameters["Target"] is Entity entity)
            {
                // Ensure the entity is the expected type
                if (entity.LogicalName != "account") // Change this to your entity name
                    return;

                // Set the Description field (modify as needed)
                entity["description"] = "This record was created on " + DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss") + " UTC.";
            }
        }
        catch (Exception ex)
        {
            // Log the error
            tracingService.Trace("UpdateDescriptionOnCreate Plugin Error: {0}", ex.ToString());

            // Optionally, throw an exception to stop execution (useful in critical cases)
            throw new InvalidPluginExecutionException("An error occurred in UpdateDescriptionOnCreate plugin.", ex);
        }
    }
}

3. Build & Register the Plugin

  • Compile the DLL.
  • Use the Plugin Registration Tool to upload the assembly.
  • Set the execution context (Pre/Post Operation, Sync/Async).

4. Test & Deploy

  • Create or update a record to trigger the plugin.
  • Verify the expected behavior in Dataverse.

Advanced Extensibility: Beyond the Basics

  1. Input & Output Parameters – Pass additional data to enhance logic.
  2. Shared Variables – Communicate between pre and post operations.
  3. Tracing & Logging – Use ITracingService to debug and monitor execution.
  4. Integration with External Systems – Call APIs or interact with Azure services.

Final Thoughts

As a consultant, your job is to provide scalable, maintainable solutions that clients can trust. Custom Dataverse plugins offer the flexibility and power needed to meet complex business requirements without compromising performance or security.

So, next time a client needs business logic enforced at the core, ask yourself: Could a plugin make this bulletproof? If the answer is yes, then it’s time to embrace the power of Dataverse plugins!

Read more