I’m sitting here with my third coffee this morning, and I’ve got to tell you—I’m genuinely excited about something Microsoft just made generally available. Code apps in Power Apps. I know, I know. It sounds like the kind of announcement that shouldn’t get anyone out of bed, but bear with me.
And here’s the kicker for us in the UK: it’s available right now in UK data regions. As of March 2026, if you’ve got Power Apps Premium licensing, you can turn this feature on through the Power Platform Admin Centre and start building pro-code solutions immediately. No waiting. No phased rollout excuses. It’s here.
The Problem We’ve All Felt
For years, we’ve been caught between two worlds. On one side, you’ve got traditional developers who want to build modern web applications using React, Vue, or whatever framework they love. On the other side, you’ve got organisations trying to keep everything secure, compliant, and integrated with Microsoft 365 and Dataverse without exploding their IT team’s workload.
The old way meant developers either:
- Abandoned Power Platform and built something external (goodbye governance, hello integration nightmares)
- Squeezed their talent into low-code constraints and watched them get frustrated
- Created shadow apps that IT didn’t even know existed
None of these are wins.
Enter Code Apps
Code apps let developers do something that should have been possible all along: build real applications using the tools they actually know, while staying within the Power Platform ecosystem.
Think about that for a second. A developer can use their favourite IDE, build with React or Vue, connect to over 1,400 Power Platform connectors (including Dataverse), and deploy it all in a way that IT actually approves of. No workaround required. No apology needed.
Why This Matters for Usability
Here’s what gets me: better tools = better user experience.
When developers have to bend their skills to fit a low-code paradigm, sometimes the user experience suffers. Not always, but it can. You end up with apps that work but feel clunky. Lots of workarounds. Janky interactions.
With code apps, if you need a custom UI component that works exactly how your business needs it—fine, build it. If you need a specific interaction pattern that feels natural to your users—go for it. If you want something that performs smoothly with thousands of records—no problem.
For UK SMBs especially, this is gold. You get:
- Professional-quality user experiences that don’t feel like an afterthought
- Real performance when you’re dealing with larger datasets
- Customisation that makes sense for your actual business, not compromises around a platform’s constraints
Dataverse: The Real Power Move
But here’s where it gets really interesting: Dataverse integration.
Code apps connect directly to Dataverse with all the same connectors the Power Platform has. That means your custom-built applications have access to the same data governance, security model, and permission framework as everything else in your org.
In practical terms:
- User logging in? Authenticated via Microsoft Entra ID automatically—no custom login page needed.
- Data access permissions? Enforced at the Dataverse level. User shouldn’t see a record? They won’t, even in your custom app.
- Compliance and data loss prevention? Built in. DLP policies apply to your code app the same way they apply to Power Pages or Power BI.
This is the thing most people don’t realise about Dataverse—it’s not just a database. It’s a governed, permission-aware data platform. When your code apps connect to it, you get enterprise-grade data governance for free.
Code Apps + Model-Driven Apps = The Perfect Combo
Here’s something that really got me thinking: you don’t have to choose between code apps and Model-Driven Apps. You build both, and they share the exact same Dataverse.
Think about how this works in practice:
Your Dynamics 365 Sales app (or a custom Model-Driven App) handles:
- CRM workflows and processes
- Standard business operations
- Reports and dashboards
- Everything your users expect from a traditional business app
Your custom code app handles:
- That specific mobile experience for your sales team
- A custom analytics dashboard with visualisations
- An integration with your partner portal
- A user experience that needed something the low-code platform couldn’t give you
Both are reading and writing to the same Dataverse tables. Same data. Same permissions. Same security. No sync scripts. No duplicate data. No “which version is the source of truth?” arguments.
A sales manager can pull up a customer record in Dynamics 365, see all the opportunities and activities. Your sales rep pulls up the same customer on their phone in your custom React app, sees their quotes and next steps. Both are looking at the same live data from Dataverse.
And here’s the genius part: when the sales rep updates something in your code app, the Dynamics 365 user sees it immediately. When the manager updates something in Dynamics, your custom app reflects it straight away. No webhooks. No sync jobs. Just live data.
This is why Dataverse is so powerful. It’s not about forcing everyone into one app. It’s about giving you the freedom to build whatever experience users need, while keeping the data unified, governed, and trustworthy.
The Architecture (Visualised)
Here’s what the architecture looks like:
┌────────────────────────────────────────────────────────────────┐
│ Microsoft 365 & Entra ID Authentication │
└────────────────────────────────────────────────────────────────┘
↓
┌───────────────────────┼───────────────────────┐
│ │ │
┌───────────┐ ┌─────────┐ ┌──────────────┐
│ Code App │ │ Dataverse │ Model-Driven │
│ │ │ │ Apps │
│ React/Vue │◄────────►│ Unified Data │ │
│ Custom UI │ │ Governance │ Dynamics 365 │
│ │◄────────►│ Security │ Business │
└───────────┘ │ │ Process │
│ • Real-time Sync │ │
│ • Permissions └──────────────┘
│ • DLP Policies
│ • Audit Logging
└─────────────────┘
↓
┌────────────────────────────────────────────────────────────────┐
│ Security: DLP • Permissions • Compliance • Monitoring │
└────────────────────────────────────────────────────────────────┘The three pillars working together:
-
Code Apps (Left) - Your custom React or Vue applications can be mobile-first, performance-optimised, and built with modern development patterns. They connect to Dataverse just like any other Power Platform app.
-
Dataverse (Center) - The heart of it all. Every piece of data lives here once, with security, permissions, and governance built in. When a sales rep updates something in the code app, when a manager updates it in Dynamics 365, they’re both updating the same source.
-
Model-Driven Apps (Right) - Your Dynamics 365 applications and low-code Model-Driven Apps work alongside code apps. They share the same data, the same permissions framework, the same governance.
Real-time sync happens automatically. No webhooks. No scheduled syncs. Just live data flowing through a single, trusted platform.
A Real Example
Let me paint a picture. You’re a distribution company. You’ve got a quoting system built into Dynamics 365. Your sales team needs a mobile app for field quoting that:
- Works offline (sometimes there’s no signal on a building site)
- Connects to your latest pricing from Dataverse
- Respects customer permission rules (you don’t want salespeople seeing quotes for competitors they shouldn’t)
- Feels fast and native, not like a web app trying to be an app
Before code apps, you’d probably:
- Build something external and live with the integration pain
- Use Power Apps canvas and work around performance limitations
- Accept that it won’t quite feel like a real native app
Now? A developer builds it with React Native or whatever they prefer, it connects to Dataverse, respects all your security rules, and ships secure through Power Platform governance. Everyone wins.
It’s Not a Silver Bullet
I should be honest though—code apps aren’t the answer to everything. For simple scenarios, low-code Power Apps canvas might still be faster. Some use cases don’t need the complexity.
But for anything that requires:
- Complex UI/UX
- Modern development patterns
- High performance
- Developer autonomy
…code apps remove the compromise. And in 2025, that’s increasingly important.
The IT Side (They’ll Like This Too)
The other thing that’s brilliant is that IT doesn’t lose control.
Zero-configuration authentication means users just log in with their Microsoft account—no custom OIDC config needed. Connectors get automatic consent flows through Power Platform. DLP policies are enforced at runtime. Conditional Access still applies. And you can monitor everything through Power Platform Monitor.
So developers get freedom, and IT gets visibility and governance. For once, everyone’s happy.
What This Means for UK SMBs
If you’re growing, you’ll probably need custom applications. Not everything fits into Dynamics 365 or SharePoint. But you also can’t afford to build outside your Microsoft ecosystem and then spend months (and thousands) integrating.
Code apps change that equation.
You can now hire developers who know the tools they love, let them build amazing user experiences, keep everything within your governance framework, and move faster than ever before.
And the best part? You don’t need to wait. Code apps are available in UK data regions right now. If you’re sitting in a UK business thinking “we need something custom,” you’ve got a proper option on the table that doesn’t mean walking away from your Microsoft investments or compromising on security and compliance.
The Takeaway
Microsoft just made it possible to have your cake and eat it too. Professional developers using professional tools, building applications that feel like they were built for your business, integrated seamlessly with Dataverse and your Microsoft 365 environment, with full enterprise governance.
Is it perfect? No. But it’s genuinely the best option for most custom application scenarios I see in UK SMBs.
And that’s worth getting excited about.
Want to explore how code apps could work for your custom application needs? We help UK businesses navigate Power Platform choices and build solutions that actually fit. Let’s chat.
