Skip to content
Back to articles
Dataverse

From CRM to Customer Experience: Building a Customer Deal Room on Top of Dynamics 365 with Lovable

I built a customer-facing Deal Room on top of Dynamics 365 using Lovable to test how an external user could participate in a CRM-driven process without ever seeing Dynamics itself. In this article, I walk through the customer experience, bidirectional write-back to Dynamics, the security gaps that still need to be solved, and where this pattern could make sense in real projects.

October 7, 20268
Share
From CRM to Customer Experience: Building a Customer Deal Room on Top of Dynamics 365 with Lovable

In my first Lovable + Dynamics 365 experiment, I built a Deal Review experience for sellers and a Pipeline Health view for sales leaders.

That led me to a more interesting question:

What happens when the person interacting with Dynamics data isn't a Dynamics user at all?

For round two, I built a customer-facing Deal Room on top of the same Dynamics 365 CE environment.

The customer never needs to see Dynamics.

Dynamics still owns the records.

What This Is For

The Customer Deal Room gives an external customer a simple place to see and act on the parts of an engagement that actually involve them.

Think:

Dynamics = system of record

Lovable = customer-facing experience

The customer sees things like:

  • Joint milestones
  • Due dates
  • Upcoming actions
  • Customer-facing contacts
  • Shared updates

They do not see the entire Opportunity record sitting behind it.

That distinction is pretty important.

When I Would Use This — and When I Wouldn't

I could see this pattern being useful for workflows like:

  • Customer onboarding
  • Renewals
  • Implementation milestones
  • Approvals
  • Partner processes
  • Document collection
  • Project status updates

Basically, situations where an external user needs to participate in a Dynamics process without needing access to Dynamics itself.

I would not use this as an excuse to expose the Opportunity table to the internet and hope for the best.

A working demo and a production security model are two very different things.

Please do not learn that one the exciting way.

Before You Start

Before building the customer experience, I wanted a few things to be true:

  • Dynamics/Dataverse remains the source of truth.
  • The customer experience only exposes information appropriate for the customer.
  • Customer actions write back to real Dynamics records.
  • Internal sales data stays internal.
  • The first test uses one Opportunity and a very small number of actions.
  • I can prove both directions of the integration before adding more functionality.

Do not be a hero.

One customer. One Opportunity. One write-back action.

Get that working first.

How I Built It

1. Start With the Existing Dynamics Process

I reused the same PetWellClinic Opportunity from my first experiment.

Dynamics already contained the Account, Opportunity, Contacts, activities, dates, and notes.

I didn't need a second customer data model.

Instead, the Customer Deal Room pulls the appropriate pieces from the existing process and presents them differently.

The question changed from:

What does the seller need to know?

to:

What do we need to do together to move this engagement forward?

2. Build a Joint Action Plan

The main part of the experience is a customer-friendly action plan.

For my demo, the journey looks something like:

  1. Discovery completed
  2. Branding direction approved
  3. Revised pricing delivered
  4. Budget approval
  5. Technical review
  6. Executive pricing review
  7. Final agreement
  8. Project kickoff

The underlying activities still live in Dynamics.

The customer just gets a much simpler view of them.

That's exactly what I wanted.

3. Let the Customer Actually Do Something

A customer portal gets a lot less interesting if it's just another place to read status updates.

So I added customer actions.

For example, the customer can mark:

Confirm final budget approval

as complete.

That action updates the underlying activity in Dynamics.

The customer sees the milestone move forward, while the internal team sees the same updated record in CRM.

No separate task list to reconcile later.

Future You will thank you.

4. Let Customer Updates Flow Back Into CRM

I also wanted the customer to be able to submit an update.

For example:

Budget has been approved. We're ready for the executive pricing review.

That update gets written back to the Opportunity as a Dynamics record rather than living only inside the customer interface.

Now the communication becomes part of the CRM process instead of another piece of context sitting in someone's inbox.

5. Be Very Intentional About What the Customer Does Not See

This ended up being one of the most important parts of the experiment.

My internal Deal Review knows things like:

  • Deal health
  • Stakeholder coverage
  • Missing economic buyer
  • Internal sales activities
  • Pipeline risk
  • Sales strategy

The customer absolutely does not need to see that.

Their experience gets things like:

  • Shared milestones
  • Relevant contacts
  • Due dates
  • Customer actions
  • Approved updates

Same Opportunity.

Very different view.

Consultant law #12: "the API returned it" is not a security strategy.

Important: This Is a Prototype, Not a Customer-Ready Security Model

This is probably the most important caveat in this experiment.

The Customer Deal Room proves that I can create a different customer-facing experience on top of Dynamics data and write customer actions back into CRM.

It does not mean I would hand this version to a real customer.

Right now, the demo does not have a true customer-level authorization model.

For example:

  • A signed-in Lovable user is not securely mapped to one specific Dynamics Account or Opportunity.
  • "Customer-visible" records are identified through conventions or labels rather than a hardened authorization rule.
  • Someone editing a Dynamics record could accidentally change whether something appears customer-facing.
  • A signed-in user could potentially access another deal unless access is enforced properly on the backend.
  • Frontend filtering alone is not enough to protect customer data.

For a production implementation, I would want:

  1. Customer authentication.
  2. A reliable mapping between the authenticated customer and their Dynamics Account or Opportunity.
  3. Server-side authorization checks before any Dynamics data is returned or updated.
  4. An explicit allowlist of customer-safe records and fields.
  5. No reliance on editable labels as the actual security boundary.
  6. Testing that proves Customer A cannot retrieve or update Customer B's data.

The frontend can decide what looks nice.

It should not be the thing deciding what a customer is allowed to see.

Ask me how I know.

Common Gotchas

Don't Turn the Deal Room Into a Customer-Facing Opportunity Form

The entire point is that the customer should see less, not more.

If a field doesn't help the customer understand what they need to do next, it probably doesn't belong there.

Don't Confuse Hidden With Secure

This is the big one.

If an internal note is hidden visually but the customer-facing API can still retrieve it, you haven't solved the security problem.

Security needs to exist behind the UI.

Not just inside it.

Make Sure the Write-Back Is Real

If a customer marks a milestone complete:

  • Did the Dynamics activity actually update?
  • Did the correct record update?
  • Did the internal experience reflect the change?
  • Does a refresh still show the correct status?

Screenshots are not integration testing.

Don't Build a Second Source of Truth

If milestones live in Dynamics, keep them there.

If customer updates belong with the Opportunity, write them there.

The last thing I want is:

Dynamics says one thing.

Lovable says another.

Someone has a spreadsheet with a third version.

That is how villains are created.

Validation Checklist

Before I'd call this working, I want to prove:

  • [ ] Customer-facing data comes from Dynamics
  • [ ] Internal-only information is not included in the customer experience
  • [ ] A Dynamics update appears in the Customer Deal Room
  • [ ] A customer milestone update writes back to Dynamics
  • [ ] A customer-submitted update creates the intended Dynamics record
  • [ ] Refreshing the app does not lose the change
  • [ ] No important engagement data exists only in the frontend
  • [ ] The security model is clearly separated from the demo UI
  • [ ] A customer cannot retrieve another customer's data
  • [ ] Customer-visible records and fields are controlled intentionally

That last group is what separates:

"This demo works."

from:

"I would let a real customer use this."

Very different bar.

A Real Scenario

Imagine a customer is in the final stages of a proposal.

Marketing has approved the direction.

Pricing has been delivered.

The remaining steps are:

  • Budget approval
  • Technical review
  • Executive review
  • Final agreement
  • Project kickoff

Internally, the seller may care about:

  • Stakeholder coverage
  • Pipeline risk
  • Deal health
  • Missing economic buyer
  • Forecasting

The customer doesn't.

They see:

Budget Approval — In Progress

They complete it.

Dynamics updates.

They add:

Budget approved. Ready for executive review.

The internal team sees that update back in CRM and continues the process from there.

Same Dynamics process.

Two completely different experiences.

The Takeaway

My first experiment was about creating different internal experiences on top of Dynamics data.

This one pushed the idea outside of CRM.

The interesting question became:

Can someone participate in a Dynamics business process without feeling like they're using Dynamics at all?

For certain workflows, I think that's where this pattern gets much more interesting.

Dynamics can continue handling the data, relationships, business process, and automation underneath.

The customer could get an experience built around the handful of things they actually need to see and do — once authentication and authorization are designed properly.

That's a much more interesting use of a custom experience layer than simply making a CRM form look different.

And just as importantly, this experiment reinforced something I think matters with AI-generated applications:

A polished UI can prove an idea very quickly. It does not automatically make the architecture production-ready.

Both are useful.

They're just not the same thing.

Next up: bringing Dynamics 365 sales data and actual invoiced revenue from Business Central into the same Account Health experience.

Tags

#lovable#ai#Tips & Tricks#data movement

Get new articles in your inbox

No spam. Unsubscribe anytime.

Related articles

You might also find these helpful