Xrm Tools for Visual Studio

After nearly a year of dedicated work, I’m excited to introduce my Visual Studio extension built specifically for Power Platform developers. As someone who’s spent countless hours working with plugins and custom APIs, I’ve experienced firsthand the unique challenges that come with building solutions on top of Dynamics 365 and Power Platform. This journey inspired me to create a tool that could make the development experience faster, safer, and more intuitive.

The Challenges of Developing for Power Platform

The dynamic nature of Microsoft Dynamics CRM — and later, Power Platform — has been one of the key factors behind its success. Thanks to its flexible architecture, independent software vendors and customers have been able to build value-added solutions that grow and evolve alongside their businesses.

However, this dynamic architecture also introduces significant challenges for developers.

In the SDK, the Entity type — which represents a table — is essentially just a dictionary. This means developers lose type safety, which leads to more fragile code. While there are tools (including SDK utilities) that can generate typed entity classes, they tend to be opinionated, verbose, and burdensome to maintain. Even with typed entities, developers still need to manually type metadata names in their code — an error-prone and frustrating task.

Furthermore, code written for Power Platform, such as plugins or custom APIs, is simply a standard class library. To integrate it with the platform, developers must go through a registration process — a separate step requiring yet another tool. Unfortunately, the user experience of the available registration tools often feels outdated by today’s standards.

While the community has done an outstanding job in building tools (especially within the great Xrm Toolbox ecosystem), developers still find themselves juggling multiple tools just to build and deploy a single plugin or custom API. This fragmentation takes a real toll on productivity.

Other challenges stem from the runtime model of plugins. For example, while dependency injection and inversion of control (IoC) are common best practices in modern software development, using them in plugins can introduce performance penalties — or worse, subtle and difficult-to-diagnose bugs.

Why I Decided to Build a Better Tool

Over the years, working with several Power Platform teams across different companies, I noticed a recurring pattern. Bigger teams often tried to fill the development gaps by creating their own reusable libraries, console applications, and custom tooling to speed up the development cycle.

While these internal tools offered short-term productivity gains, they came with long-term risks. They often introduced steep learning curves and required significant configuration, merely shifting complexity from the platform to the tool itself. Maintenance became another burden — typically falling onto a few “core” developers. If one of these key developers left the company, maintaining and updating the tools became a major challenge. Worse, these tools were often so opinionated and tightly coupled to the company’s way of working that developers couldn’t take the experience or productivity gains with them when moving to another organization.

As someone who regularly built plugins for various projects, I started thinking seriously about creating a proper Visual Studio extension — one that didn’t come with a high learning curve, felt natural inside Visual Studio, and was based on a simple, universal principle: registration and everything else as code.

This approach brings enormous advantages. Registrations become traceable, auditable, and testable — just like any other code. Developer intent becomes explicit and visible, enabling opportunities like automated code generation and real-time code analysis through custom analyzers.

Of course, bringing first-class support into Visual Studio is no small task. Features like syntax highlighting and auto-completion for metadata — which can change at any time — are notoriously complex compared to working with static language syntax.

Originally, I planned a very focused MVP (minimum viable product) with just a handful of features. But once the core pieces fell into place — achieving the performance, security, and usability I expected — I decided to go further. I expanded the extension to support a complete flow, from implementation all the way through deployment, without forcing any specific architectural style on developers.

Instead of dictating how solutions should be built, the extension adapts to the developer’s preferred architecture. Out of the box, it offers powerful features like dependency injection support for plugins, typed Custom API generation, and more — but developers are free to opt in, opt out, or even fully customize code generation templates directly inside Visual Studio.

Introducing XRM Tools: Power Platform Development, Natively in Visual Studio

XRM Tools brings native Power Platform development support directly into Visual Studio, enabling developers to apply proven software development practices with ease.

By defining everything as code — registrations, metadata, deployment configurations — XRM Tools builds on concepts that developers have been relying on for decades. Instead of relying on external tools with fragmented experiences, developers can now stay entirely inside Visual Studio, using familiar workflows like source control, code reviews, and automated testing for their Power Platform solutions.

At its core, XRM Tools aims to remove friction:

• Registrations are handled as code, making them easy to trace, review, and evolve alongside the business needs.
• Metadata is accessible and integrated, enabling smart IntelliSense, validation, and code generation tailored to the live environment.
• Deployment workflows are streamlined, bridging the gap between building and publishing solutions without leaving Visual Studio.
• Customization and flexibility are first-class citizens — developers can adapt code generation templates to match any architectural style, without being forced into a particular pattern.

From intelligent code generation to seamless deployment integration, XRM Tools transforms the Power Platform development workflow into a faster, safer, and more modern experience.

Key Highlights of XRM Tools

✅ Registration as Code

Define and manage plugin registrations entirely as code, making them easy to track, audit, review, and version alongside your source code.

✅ Smart Metadata Integration

Real-time access to your Power Platform environment’s metadata directly inside Visual Studio, powering IntelliSense, validation, and automated code generation.

✅ Environment Management — Your Way

Manage environments flexibly at the Visual Studio Options, solution, or project level. Decide whether environment settings are shared with the team or kept private per developer. Securely authenticate using Microsoft’s SDK, with seamless support for integrated authentication, client certificates, client secrets — all safely stored using environment variables or the OS credential manager.

✅ Intelligent Code Generation

Generate strongly-typed plugin classes, custom APIs, and more as you write your code, with templates that you can fully customize to match your preferred coding style or architecture.

The default templates give you a lot already that you may never need to modify. Think about code-generated dependency injected and types Target or typed request and response for custom APIs.

✅ Seamless Deployment

Deploy a single plugin or an entire assembly with a single click — all handled in a single, reliable transaction.

✅ Support for Both Plugin Models

Whether you’re building traditional plugins or the newer model with NuGet package support for dependent assemblies, XRM Tools has you covered.

✅ Visual Studio Native Experience

Full theme integration, rich IntelliSense, syntax highlighting, and a clean, natural workflow that feels like a native part of Visual Studio.

✅ Flexible by Design

Opt-in features like dependency injection support, typed entities, customizable code generation — without forcing any particular architecture.

🥁 Next up: One-Click Debugging

Work is already underway to enable one-click debugging: simulate real plugin execution in a live environment by simply pressing F5 — no manual setup needed.

Another potential worth exploring is to implement code analyzers to make sure we are following best practices or not making mistakes that cannot be detected by the compiler.

I have in mind to support VSCode at some point, but I will decide when I have more feedback from users like you out there.

Try XRM Tools Today!

XRM Tools is now available on the Visual Studio Marketplace, and I would love for you to try it out.
Whether you’re building a small plugin or managing complex enterprise solutions, XRM Tools is here to make your development experience faster, safer, and more enjoyable — all without leaving Visual Studio.

👉 Download XRM Tools from Visual Studio Marketplace

I’m always looking for feedback, ideas, and ways to improve.
Feel free to share your thoughts, feature requests, or even just say hello — let’s shape the future of Power Platform development together!