Introducing Mermaid to Dataverse Converter

Why diagrams matter (and why they usually fail us)

Entity-Relationship Diagrams (ERDs) are the universal shorthand for talking about data models. They show what entities exist, which attributes they carry, and how they connect to each other. In workshops, they are invaluable: they help everyone get on the same page, and they force the team to make decisions about terminology early on. Is it a Customer or an Account? Do we store Address inside the Order or separately? These are the conversations you want to have at the whiteboard.

The tragedy is that most ERDs end their lives inside a Visio file, a Confluence page, or, if you’re truly unlucky, a PowerPoint deck. They look polished for the kickoff meeting. Six weeks later they’re a lie. The system has moved on, but the diagram is frozen in time. Nobody trusts it anymore. What was supposed to be the map has become a fossil.

Mermaid: diagrams that behave like code

Mermaid.js changes the game because it treats diagrams as text. Instead of dragging rectangles around a canvas, you write a few lines that describe your model. Those lines render into a clean diagram, every time. No one is fiddling with connectors or fighting layout engines; the syntax is simple, readable, and versionable.

What you see here isn’t a static sketch. It’s code. You can put it into Git, track changes, open pull requests and more. The diagram becomes part of the software, evolving alongside the rest of the project. That alone is already a big step forward from Visio archaeology.

From drawing to deployment

But I didn’t want to stop at documentation. I built the Mermaid to Dataverse Converter, an Azure App Service that takes your Mermaid ERD and provisions the schema directly into Microsoft Dataverse.

The diagram that once lived in a deck now becomes the thing that creates your environment. The converter generates publishers and solutions, defines entities with their attributes, provisions one-to-many and many-to-many relationships, respects global choice sets, and even maps to existing Common Data Model entities where possible. What started as a design artifact in a customer meeting ends up as a working Dataverse solution a few minutes later.

What about plan designer?

If you’ve been following the Power Platform updates, you’ve probably seen Plan Designer. It’s Microsoft’s AI-driven canvas for solution design. You type in a prompt, sometimes upload an image, and it drafts a whole plan for you: tables, relationships, apps, flows, even a portal. It’s impressive, and for quick ideation it’s a fantastic tool.

But prompts are not code. They look like they could be versioned, but they aren’t deterministic. The same words might give you a different schema tomorrow. You can check a prompt into Git, but you can’t guarantee the output will be identical next time you run it. That makes deployments unpredictable.

You can call it a proof of concept or an MVP, and that’s fine if it stays a sketch. The reality, though, is that proofs of concept have a bad habit of sneaking into production. Once users see something that works, they keep using it. Suddenly you’ve got live data sitting on a nondeterministic schema that you can’t repeat or redeploy with confidence.

Mermaid to Dataverse Converter takes the opposite path. The file is text. The output is deterministic. The same diagram yields the same schema every time, no surprises. It can be versioned properly, reviewed properly, and deployed properly. That’s the difference between a sketchpad and infrastructure. Plan Designer is great for sparking ideas; Mermaid to Dataverse Converter is what you reach for when you want something you can trust on a Friday night rollout.

documentation as infrastructure

Because Mermaid is plain text, it slides neatly into the practices we already use for code. You commit it, version it, and push it through a pipeline. Every schema change becomes visible in source control, every adjustment is reviewable, and every environment can be provisioned automatically from the same source.

This is what Infrastructure as Code looks like in the Dataverse world. The ERD is no longer a sketch you present to stakeholders. It’s the blueprint that shapes the environment, always up to date because it has to be. The usual drift between documentation and reality disappears, because they are literally the same thing.

Rage against the docs

For too long we’ve tolerated diagrams that die in SharePoint folders and slide decks that mislead more than they guide. We’ve accepted documentation as a necessary evil that will always be out of date. That’s nonsense. Documentation should be as alive as the system it describes. It should be part of the build, not a side note.

Mermaid plus Dataverse finally lets us do that. Define the model, check it in, and let it provision itself. Stop treating diagrams like art projects. Start treating them like infrastructure.

Try it out

The Mermaid to Dataverse Converter is open source. It’s deployed within a few minutes. Grab an ERD, upload it, and run it through the converter. Watch your documentation turn into a Dataverse solution. The next time someone asks for “the latest version of the diagram,” you can point to GitHub, and to the running system, and know they are the same thing.

Would love to get your feedback! 💖