I've been experimenting quite a bit with Lovable and Microsoft Dynamics 365 lately, and one thing that continues to impress me is how quickly you can build custom applications around existing CRM data.
In my previous articles, I explored building a Deal Review experience and a Customer Deal Room using Lovable and Dynamics 365.
Those projects got me thinking about something beyond the initial build.
What would it actually take to deploy and manage an AI-generated application for real business use?
Not just publishing a working prototype, but thinking through source control, security, authentication, hosting, integrations, and how changes will be managed over time.
I'm currently exploring this through an internal project at the Microsoft consulting firm where I work.
It's still a work in progress, but I've already come across some interesting considerations that I wanted to share.
The Goal: Moving From a Prototype to a Managed Application
The application I'm investigating is an internal case-management experience built using Lovable, with an existing integration to Dynamics 365.
The goal isn't to rebuild the entire application.
Instead, I'm exploring how we can continue taking advantage of Lovable for rapid development while introducing more control over the application's source code, hosting, authentication, and deployment process.
The general direction I'm investigating involves:
- Lovable for building and iterating on the application.
- GitHub for source control and collaboration.
- Microsoft Azure as a potential hosting environment.
- Microsoft Entra ID for organizational authentication.
- Dynamics 365 and Dataverse for the underlying CRM data and business processes.
This is the proposed direction, not a finalized architecture.
And one thing has already become clear: moving an AI-generated application into a managed hosting environment involves more than exporting the code and clicking Deploy.
When Does This Approach Make Sense?
I can see a lot of potential for organizations that already use Dynamics 365 or Dataverse but want more flexibility in how users interact with their data.
Maybe it's a custom dashboard for a support team, a focused application for managing internal requests, or an interface that simplifies a complicated business process.
AI development tools make it much easier to experiment with these experiences without starting a traditional frontend project from scratch.
But that doesn't mean every organization needs a separate custom application.
If a model-driven app, canvas app, or Power Pages site already meets the requirements, those options may be simpler to implement and maintain.
Similarly, Lovable's managed hosting may already be appropriate for some applications.
The point of this investigation isn't to suggest that every Lovable application should move to Azure.
It's to understand what options are available when a business wants more control over how an application is deployed and operated.
Pre-Flight: Understand the Existing Architecture
Before choosing an Azure hosting service, I wanted to understand how the existing application actually worked.
A few of the first things I investigated were:
- What framework is the application built with?
- Where is the application database hosted?
- How does the application connect to Dynamics 365?
- How are credentials and secrets handled?
- Are development and published environments isolated?
- What happens to the application when code changes?
These questions matter because a working frontend doesn't tell you everything about the systems supporting it.
Gotcha #1: Preview Doesn't Automatically Mean an Isolated Development Environment
One of my first findings was that the existing application's preview and published experiences used the same underlying backend resources.
That meant changes made while testing could potentially affect the data used by the published application.
For a business application, that's something I wanted to address before experimenting with integrations or deployment changes.
So I created a separate Lovable development project.
I verified that the new project had its own database, with the expected tables but no existing records. I also checked for hard-coded production endpoints and removed the Dynamics integration secrets from the development setup.
The existing integration was configured for manual synchronization rather than scheduled synchronization.
These checks gave me a much cleaner starting point for development.
They don't replace full environment and security validation, but they help avoid unintentionally mixing development activities with published application data.
Do not be a hero and test against production simply because the screen says Preview.
What I've Found So Far
1. GitHub: Source Control Is Only the Beginning
The next area I'm working through is GitHub integration.
Lovable supports two-way source-code synchronization with GitHub. This allows developers to access the code outside the Lovable editor and introduces opportunities for code reviews, testing, and deployment pipelines.
I've joined our organization's GitHub environment and started working through the permissions needed to connect the development project.
The actual Lovable-to-GitHub integration is still being set up, so I haven't validated that workflow yet.
Once it's connected, I want to test how code changes synchronize and determine how we can manage releases.
An important distinction here is that GitHub synchronization is not the same as a complete deployment process.
Having your application code in a repository doesn't automatically migrate the database, configure secrets, move backend services, or establish a reliable release strategy.
Those responsibilities still need to be accounted for.
2. Azure Hosting: What Are We Actually Moving?
Initially, the hosting question sounds straightforward.
If we can access the source code, can we deploy the application in Azure?
Potentially, yes.
But the next question is what the application actually requires to run.
The application I'm investigating uses TanStack Start, a full-stack React framework that supports server-side rendering, server functions, and server routes.
That's an important distinction from a purely static frontend.
You can't automatically assume that uploading the build files to a static hosting service will support everything the application needs.
The actual runtime requirements and deployment configuration need to be validated.
And there's another consideration.
Moving the application frontend doesn't necessarily mean moving its backend.
An application may depend on a separate database, authentication services, storage, and integrations.
You could successfully host part of the application in Azure while other components continue running elsewhere.
That isn't inherently wrong.
But if the goal is to control where application components and data are hosted, you need to understand those dependencies before deciding on the architecture.
For this project, I'm still evaluating the appropriate hosting approach. I haven't completed an Azure deployment yet.
An Interesting Development From Lovable
While I've been investigating this, Lovable announced Deploy on Azure on October 15, 2026.
This capability is currently in private preview for select Lovable Enterprise customers.
It is designed to let eligible organizations run application infrastructure and data within their own Azure subscription while continuing to use Lovable's development experience.
That's a different approach from exporting code through GitHub and independently configuring an Azure deployment.
Lovable's offering is interesting because it may reduce some of the infrastructure work required for organizations that qualify.
For my current investigation, I'm exploring the source-code and Azure hosting approach while continuing to evaluate the available options.
It's worth understanding the differences before deciding which one makes sense.
3. Authentication and Dataverse Security
This is another area I'm particularly interested in getting right.
One of the proposed changes involves integrating Microsoft Entra ID for organizational sign-in.
But implementing sign-in is only part of the security design.
Authentication answers who the user is. Authorization determines what they're allowed to access.
When a custom application connects to Dataverse, you need to consider which identity is used for the actual data operations.
For example, a supported approach is to authenticate to Dataverse using the signed-in user's delegated permissions.
Another is to use a Dataverse application user for server-to-server access.
These approaches have different security implications.
When operations execute under an application identity, Dataverse evaluates the application user's assigned privileges. That doesn't automatically enforce each frontend user's individual access requirements.
The application architecture needs to account for that distinction.
This becomes especially important when different employees or teams should only access certain Cases, Accounts, or other CRM records.
I'm still evaluating the authentication and authorization design for this project. I haven't implemented or validated the final Entra ID configuration yet.
And it's something I want to get right before considering the application ready for broader use.
4. Don't Overlook the Integration Strategy
Another interesting finding relates to how the existing application retrieves Dynamics 365 data.
The current integration uses a manually triggered synchronization process to bring information from Dynamics into the application's backend database.
That works for the existing design, but it raises an important question:
How current does the information actually need to be?
Imagine a support representative opens the application and sees a Case marked In Progress.
Someone updates the Case directly in Dynamics 365 to Resolved.
If the application only refreshes its data when someone manually triggers synchronization, it may continue displaying the previous status until the next successful sync.
The frontend isn't necessarily broken.
The integration could be functioning exactly as designed.
But that design may or may not meet the business requirements.
Depending on the scenario, a team might need scheduled synchronization, event-driven updates, or direct retrieval of data.
And if you're keeping a separate copy of CRM data, you also need to consider what happens when synchronization fails, how errors are monitored, and whether updates can occur in both systems.
This is something I'll be considering as the integration approach evolves.
Common Gotchas Worth Thinking About
A few things I'm keeping in mind as I work through this:
GitHub access doesn't mean you have a complete ALM process. You still need to design how changes are tested, approved, and released.
Azure hosting doesn't automatically mean everything runs in Azure. Backend services and databases need to be considered separately.
A working Entra ID sign-in doesn't prove that Dataverse access is secure. Authentication and authorization must both be validated.
A separate development project doesn't eliminate every integration risk. Secrets, endpoints, and external dependencies still need to be checked.
A successful data sync doesn't mean your information is always current. Data freshness should match the business process.
None of these are necessarily limitations of Lovable itself.
They're application architecture considerations that apply to custom software generally.
AI-assisted development just makes it possible to reach this stage much faster.
Validation Checklist: What's Still Ahead
Before I can put together a full deployment walkthrough, there are several things I still need to validate.
Completed So Far
- [x] Reviewed the existing application architecture.
- [x] Identified the application's framework and hosting considerations.
- [x] Created an isolated development project and database.
- [x] Confirmed the development database had no existing records.
- [x] Reviewed the existing synchronization approach.
- [x] Removed the development project's Dynamics integration secrets.
- [x] Started setting up organizational GitHub access.
Still in Progress
- [ ] Complete and test Lovable-to-GitHub synchronization.
- [ ] Finalize the Azure hosting approach.
- [ ] Deploy and validate the application in an Azure test environment.
- [ ] Determine the required backend hosting and configuration changes.
- [ ] Implement and test the Entra ID authentication approach.
- [ ] Validate authorization and Dataverse permissions.
- [ ] Reconnect and test the Dynamics integration using the approved configuration.
- [ ] Establish and test the release, monitoring, and rollback process.
I want to validate these pieces before making any claims about a completed deployment.
Future You will thank you for documenting what was actually tested instead of assuming that everything worked because the app loaded successfully.
The Bigger Picture: AI Makes Development Faster, Not Architecture Optional
What I find most interesting about this project is that it brings together two areas I really enjoy: building new experiences with AI and designing solutions around Microsoft business applications.
Lovable makes it possible to move from an idea to a working application surprisingly quickly.
Dataverse gives us an established platform for managing CRM data, relationships, and business processes.
But when you combine the two, you still need to think about how the application will be operated, secured, and maintained.
And those considerations aren't exclusive to large organizations.
A small business managing internal support requests still needs to protect its customer information.
A growing consulting firm still needs to understand where its application data lives.
And a company of any size benefits from having a reliable way to test and release changes.
The appropriate level of complexity will vary, but the responsibility doesn't disappear.
What's Next?
I'm continuing to work through the GitHub integration, Azure deployment options, and Entra ID authentication design.
Once I have a working deployment and have validated the integration and security approach, I'll come back with a more technical follow-up covering the actual architecture, deployment steps, lessons learned, and anything unexpected along the way.
For now, this is an ongoing investigation rather than a finished implementation.
But I think it's an interesting one.
Because building an application with AI is becoming easier than ever.
Figuring out how to run that application reliably for a real business is where the solution architecture gets interesting.