Skip to content
PodSubs
ShowsPeopleGuestsJobsNewsEvents
More
BlogPodCred
Menu
ShowsPeopleGuestsJobsNewsEventsBlogPodCredNetworksSign in
Join nowSign in
  • Shows
  • People
  • Jobs
  • News
  • More
    • Guests
    • Events
    • Blog
    • PodCred
    • Networks
    Join nowSign in

Support Engineering Weekly

Support Engineering Weekly artwork

The Power Platform Isn't Three Products: It's an Architecture

Sep 20, 202621 minAudio

Why does the Microsoft Power Platform become difficult to support when Power Apps, Dataverse, and Power Automate are treated as isolated products? In this episode, Alex and Maya examine the Power Platform as an architecture, with clear responsibility boundaries between the user experience, governed business data, orchestration, integration, compute, analytics, and the control plane. The discussion explores deliberate handoffs between Power Apps, Dataverse, and Power Automate, the event-driven pattern that connects them, why Dataverse should be treated as shared business context rather than simple storage, and why specialized compute and analytics belong in the appropriate services instead of inside apps or flows. The episode then examines enterprise control through environments, application lifecycle management, data loss prevention, and workload-level security. The conversation also looks at the 2026 direction of the platform, including Copilot, autonomous AI agents, and agentic low-code development, and explains why AI does not replace architecture. Instead, AI makes clear identity structures, governed data, security boundaries, integration controls, and proper ALM even more important. The central lesson is straightforward: start with the workload, define clear responsibility boundaries, use deliberate handoffs, and treat the Power Platform as an integrated architecture rather than three separate products. This episode is based on the Support Engineering Blog article “The Power Platform Isn't Three Products: It's an Architecture”, including its architectural model, responsibility boundaries, deliberate handoff pattern, Dataverse business context, integration and compute guidance, control-plane principles, security model, and supporting diagrams. Chapters 00:00 - Three Products or One Architecture? 02:07 - Responsibility Boundaries 04:51 - Deliberate Handoffs and Events 07:57 - Dataverse as Business Context 10:28 - Integration, Compute, and Analytics 13:16 - The Control Plane and ALM 15:53 - Security Across the Workload 17:00 - AI Doesn't Replace Architecture 19:19 - The Workload-First Architecture Model Learn more: The full technical article, references and supporting resources are available through the Support Engineering Blog at https://blog.sadhan.ch.

Audio and video play straight from the show's own hosting. PodSubs stores and serves no media.

Transcript

From the show. Tap a time to play from there.

You are listening to Support Engineering Weekly. Have you ever looked at Microsoft's power platform and felt like you were just throwing a bunch of disconnected tools at a problem? Oh, absolutely. Like you've got this bucket of software parts, right? Yeah, exactly. Canvas app here, a flow over there, maybe a SharePoint list, just holding on for dear life. And you're just sort of hoping they all fit together when you hit publish. Right. And if you are listening to this right now and wondering why your supposedly simple application takes 10 seconds

to load a single screen, well, this right here is probably your culprit. It is an incredibly common feeling in the engineering world right now. You end up trying to force one tool to do a job who is, you know, absolutely never designed to do. And suddenly, your Quick Fix productivity app mutates into this tangled, unmanageable mess that the support team has to untangle on a Friday afternoon. Which is everyone's favorite way to end the week? Definitely. Welcome to a special deep dive into today's technical

sources, framing up a deep dive for support engineering weekly from the Sport Engineering blog. I'm Alex. And I'm Maya. Thank you for joining us on this deep dive today. So today's mission, our working title, is basically this. The power platform isn't three products. It's an architecture. Which is such an important distinction to make. It really is. The core thesis from our source material is that if we want to build real production-ready systems, we have to unlearn some bad habits. We have to stop asking, which product should I deploy?

And start asking, what is the workload? Right. Because when you first learn these tools, you almost always learn them in total isolation. Yeah. Like you take a weekend tutorial. Exactly. You take a quick tutorial on Power Apps to build a form. Then maybe months later, you take a separate one on Power Automate to send an email. Which is great for learning the basics. That isolated mindset is usable when you are just starting out. But for a true enterprise production workload, treating them as separate islands is just a massive liability. So how does the source material suggest we fix that?

Well, the framework in our sources dictates a very strict responsibility for each component. Let's break down the boundaries. First, Power Apps owns the experience. The experience, all right. Yeah. That means the user interface, the navigation, presenting the forms, capturing human input. It's basically the glass the user taps on. Okay. Let's unpack this because I think an analogy really helps visualize this separation of concerns, especially when we start talking about architecture to stakeholders.

Oh, analogies are great for this. Right. So think of this architecture like a high-end, busy restaurant. Power Apps is your front-of-house staff. The waiters and hosts. They present the menu. They interact directly with the customer. They do have the order and they make sure the dining room looks great. They completely own the experience. Exactly. Dataverse, on the other hand, is the secure inventory and the master recipe book locked in the back. It's the absolute single source of truth for what ingredients you have, how things are supposed to be made, and who has the keys to

the pantry. I love that. And Power Automate. Power Automate is the expediter standing in the middle of the kitchen. It's taking the tickets, coordinating the different chefs, making sure the stakes fire at the right time, and taking action at the right time. And the current state of the kitchen. That analogy holds up incredibly well. And the reason the source material so strongly warns against blurring these architectural lines is because of what happens when, well, to use your analogy, when the front-of-house staff tries to jump on the grill and cook the meal. Oh, that would be a disaster. Or when the kitchen expediter tries to walk out and seat the

guests. The application itself shouldn't become the workflow engine. Right. Think about the war stories we hear from support engineers. Somebody builds massive, complex data processing loops directly inside a Power app button click. Oh, I've seen that parsing thousands of rows of data right in the UI layer. Yes. And the app inevitably becomes incredibly sluggish. The user thinks the system is broken and the code is totally unmaintainable. And the reverse is true too, right? Like the workflow shouldn't become the user interface.

It really shouldn't. You see teams using Power Automate approval emails as a complete substitute for a proper user interface just because they wanted to skip building an app. Yeah, they cram all this operational logic right into an email body. Exactly. But when each tool stays strictly in its lane, you know, the waiter waits, the database stores, the expediter coordinates the whole system scales beautifully without bottle-necking. But if each tool has this incredibly strict bandry, how do they actually talk to each other when a user interacts with the system?

That's the million dollar question. Right. So the meal ticket actually get from the dining room to the kitchen without the waiter stepping over the line. So the sources map out this core architectural pattern and it relies on a very deliberate handoff between these layers. A deliberate handoff. Yeah. The sequence diagram in the source is incredibly specific about this handoff mechanism and it is vital to get it right. Let's walk through the mechanics of a typical interaction. Okay, let's hear it. Step one, the user submits a request or fills out a form via power

apps. Step two, power apps does not immediately trigger an external action or fire off an email. Wait, it doesn't? No. Instead, it simply writes a business data record to dataverse. Wait, I have to push back on this. Why not just have power apps call the external system directly and skip dataverse entirely? I hear that all the time. I mean, if I have a Canvas app, I can just drop an Office 365 connector right in there. It seems way faster to just code the API call right there on the button press in the app and be done with it. What's fascinating here is the long-term engineering consequence

of taking that exact shortcut. It feels faster on day one, but is a total trap. A trap? How so? If the app does everything, like if you wire the UI directly to external APIs, the app starts accumulating presentation logic, orchestration logic, and integration logic, it becomes a massive, unmaintainable monolith. Oh, so it just gets bloated? Exactly. Yeah. And the think about it, if that external API changes its authentication method next year, or if your business decides they

now need a manager's approval step before that API is called? Oh, I see. You'd have to rip open the user interface to fix a back-end process. Yes. You have to take the app completely offline, but if you use deliberate handoffs as the architecture intends, you completely decouple the user experience from the back-end process. That makes a lot of sense, but how does that actually work in practice? Yeah. If the app is just dropping a record into dataverse, does power automate just sit there, pulling the database every five seconds, waiting for a new row to appear?

Pulling every five seconds? No, no. Because that sounds like a great way to destroy your system performance. It would be. And that is where the underlying mechanism of the platform really shines. It does not use polling. It uses an event-driven architecture. Ah, okay. Dataverse has native event handlers. So, step three in our sequence. That dataverse data change, the underlying data event itself, not the main thing that you can click in the app is what wakes up power automate. So, the data change triggers the flow. Exactly.

Then step four, power automate takes over. It does the heavy lifting externally, maybe reaching out to Microsoft 365 to create a task, or calling an external API. Then it updates that same dataverse record with the new status, like changing it from pending to complete. Finally, step five. PowerApp simply reads that updated status from dataverse to show the user the current progress. So, if the external legacy system changes, you only ever update the power automate flow. Right. The app never even knows the difference. It just looks at dataverse and says, hey, the status changed to complete.

Let me show a green check mark. The app remains completely ignorant of the backend complexity, which is exactly what you want. Deliberate handoffs produce clearer, more resilient architecture. That is a brilliant design. But this whole deliberate handoff strategy relies entirely on dataverse sitting right in the middle of everything, acting as the anchor. It does. We really need to explore why dataverse is positioned in these sources as the shared business context, and not just a giant storage bin for records.

I think a lot of people just view it as a slightly fancier share point list. Yeah. And comparing dataverse to a SharePoint list, or even just a raw SQL database completely misses the point of its position in the architecture. How so? Well, dataverse is providing govern operational business data right at the platform boundary. It's not just holding flat tables of text. It's holding the complex relational structures, the metadata, the security hierarchies, and the business logic that define how your actual organization operates.

Here's where it gets really interesting. If you define your security roles, your data relationships, and your data-centric business rules directly in dataverse, you don't have to recreate them in every single power app or automation you build. Exactly. So, if you access this central hub. Yes. The defined ones use everywhere principle. If you build a rule in dataverse that says a discount over 20% requires a VP signature dataverse enforces that at the API level. So it doesn't matter if a user tries to apply that discount through a Canvas app,

or through a Power Pages portal, or through an automated flow. Nope. Dataverse basically acts as the bouncer and rejects it if it breaks the rule. Exactly the point. And that points directly to one of the most common architectural mistakes identified in the source, treating dataverse as only a database. Just a dumb storage container. Yeah. Right. If you ignore dataverse's native APIs, it's robust auditing logs, it's lifecycle capabilities, and it's granular governance features, you are robbing the platform of its central nervous system.

Which is a huge waste. It is. When you use it just as a storage container, you inevitably end up pushing all that critical business logic back into the apps themselves. Which leads us right back to the monolithic nightmare we just talked about avoiding. Because if you build a second app, you have to rewrite all those rules from scratch. Every single one of them. Okay. So dataverse handles all that internal business context securely. But a real production level workload eventually has to talk to the outside world. Of course. It has to perform complex logic or integrate with legacy third party tools that your company

bought a decade ago. If we aren't doing that in the app and dataverse is primarily governing the data, where does the actual heavy lifting happen? That brings us to the integration and compute layers. The sources detail over 900 standard connectors out of the box. Wow. 900. Plus the ability to build custom connectors, dedicated APIs, and utilize Azure services. This is where you step outside the core triad of apps, dataverse, and automate. This integration layer allows the platform to communicate securely with external systems.

I have to ask though, if power automate is our orchestrator, our kitchen expediter, from the analogy, shouldn't it handle all the heavy data crunching and complex math? Oh, definitely not. I mean, I've seen engineers build massive nested loops in power automate to parse huge arrays of JSON data or calculate complex financial amortization tables. If we connect this to the bigger picture, that is a massive anti-pattern that brings support teams to tiers. Really? Yes. Power automate is designed to coordinate work, to route tasks, and to manage state transitions.

It is absolutely not designed to perform heavy specialized compute. I once saw a flow where someone tried to parse 50,000 rows of Excel data inside a single apply to each loop in power automate. Oh, no. The flow took 12 hours to run and practically caught fire. Oh, wow. That is a nightmare. So where should that math happen? If you have complex mathematical modeling, heavy data parsing, or long running computations, that specialized compute belongs in Azure functions or custom APIs. So you hand it off again.

Exactly. You have power automate, call the Azure service, let Azure do the heavy lifting in a fraction of a second and have it return the result to the flow. Shoving complex compute into power automate just makes your workflows brittle, incredibly slow, and nearly impossible to debug. That is such a crucial distinction for listeners to grasp. It's an orchestrator, not a calculator. Perfectly said. And the sources make another huge distinction here regarding the analytics layer, specifically regarding Power BI and Microsoft fabric.

Yes. The source dictates a very hard line regarding data workloads. Operational workloads, which live in dataverse, must remain strictly separate from analytical workloads, which live in Power BI or fabric. So keep them apart. Do not let your transactional application become a reporting engine. I think we've all seen this. Someone wants a real time dashboard showing five years of sales trends, and they try to build massive, aggregated business intelligence charts directly inside a Power app using live dataverse queries. And doing that will completely destroy the performance of the app for the people actually

trying to do data entry. Right. Dataverse is for the transaction, the moment to moment operational state of your business. When you need to analyze a million rows to find quarterly trends, you pipe that data out to Microsoft fabric or Power BI. Yeah. Let the analytical engines do the analytical work. You have to keep those responsibilities separated. Okay. So we've mapped out this really structured logical flow. Okay. The data flows from the user experience layer in Power Apps down into dataverse for governed business context. Yeah.

It's orchestrated by Power Automate and it pushes out to Azure APIs or connectors for the heavy compute. Exactly. But with data flying across all these different boundaries, how on earth does an engineer or an IT leader keep it secure? How do you keep it organized and stop it from turning into the Wild West? You have to wrap the entire workload in what the architecture calls the control plane. We aren't just talking about app level passwords or sharing links here. What are we talking about them? We are talking about overarching environments, application lifecycle management or ALM data

loss prevention policies and deep monitoring that surrounds the entire workload. Let's define some of this for the audience because the acronyms can get heavy. When we talk about data loss prevention or DLP, we mean the rules that stop someone from say building a flow that accidentally tweets out the company's highly confidential payroll data from a secure database, right? Exactly that. DLP policies govern which connectors are allowed to communicate with each other. And then we have application lifecycle management which dictates how you actually deploy this

software. I like to think of ALM like a theater production. You have your messy rehearsal room where the actors are dropping lines and figuring things out. That's your development environment. I like this analogy. Thanks. When you move to the dress rehearsal on the real stage to see if the lighting works, that's your managed test or UAT environment where real users do acceptance testing. And finally, you have opening night, which is your locked down production environment. That's a great way to put it. And the source throws up a massive red flag here regarding deployments.

Building everything in the default environment is a colossal anti-pattern. It is perhaps the most dangerous anti-pattern in the entire ecosystem. Every tenant comes with a default environment, but it is meant for personal productivity, like a user automating their own email inbox. Not for company white apps. Right. It is not for enterprise workloads. If you build a mission critical workload in the default environment, you have zero isolation. You can't control updates properly. You can't segregate your test data from your live production data.

And you are essentially developing live on opening night, which is terrifying. It is proper ALM means you package your components into a single solution. You use environment variables, so your app knows which database to look at. And you use automated pipelines to promote that solution cleanly across those isolated environments. And that ties directly into how security is handled across the entire architecture. Yeah. Because security isn't just a toggle switch you flip on the Canvas app. The source makes a profound workload level security argument here.

Security crosses every single boundary we've discussed today. A completely secure power app locked down with perfect role based access control is completely useless if a connected power automate flow or an external connector has excessive permissions. Right. If your app only lets a user see their own specific client records, but your flow in the background runs under a global service account that has permission to delete the entire database, well, you have a massive gaping hole in your architecture. Yes. And if someone figures out how to trigger that flow maliciously or even accidentally through

bad input, you have a major data breach on your hands. That's scary. Security belongs to the architecture, not just the app. It spans user identity, the principle of least privilege, data versus table permissions, and those DLP policies we mentioned. It really forces you to zoom out and look at the whole board rather than just staring at the single app screen you were building. It really does. Now we've mapped out this rigorous, highly structured architecture. We have boundaries, deliberate handoffs, ALM pipelines, and workload level security.

But we have to look at the 2026 direction highlighted in the sources. How does artificial intelligence change all of this? Oh, that's the big one. Yeah. The documentation points to a heavy reliance on AI assist development and agentic low code across all these layers. It's the biggest shift in the landscape right now. We're seeing co pilots, autonomous AI agents, and automated reasoning being injected directly into every layer of the platform we just discussed. So what does this all mean? If I have an AI agent that can just build things for me or an AI that can route tasks

autonomously without explicit if-then statements, does this new wave of co pilots replace the need for all this careful layer planning? Can I just tell the AI to build me a customer management system and completely ignore the boundaries? This raises an important question, and it's one a lot of IT leaders are getting dangerously wrong right now. The source's stance is unequivocal. AI and agents sit on top of the foundation. On top of it. Yes. They rely entirely on your identity structures, your data relationships, your security model,

and your integration layers. AI does not eliminate the need for architecture. It actually makes getting it right vastly more important. Can you break down why it goes wrong? What happens if you skip the foundation? Think about it. An AI agent is essentially a very fast, very eager worker. It is only as smart as the structured data it has access to, and it is only as safe as the boundaries you've drawn around it. If you point an AI agent at a poorly architected default environment where connectors aren't controlled by DLP, where data isn't strictly governed by data verse roles and where ALM

is nonexistent, you aren't scaling productivity, you are scaling chaos. Because an AI agent with excessive permissions operating in a monolithic, badly designed environment will just make mistakes at the speed of light. It could hallucinate an approval and delete a thousand records before you even realize what happened. Precisely, the foundation, the clear separation of experience, data, and orchestration is what provides the guardrails. It is what makes the AI safe and effective. That is a terrifying but incredibly necessary perspective for anyone building in this space.

Let's synthesize a weave on pack today for everyone listening. Whether you are a support engineer cleaning up these messes or an architect designing them. The biggest takeaway from these sources is that you have to start with the workload. Stop treating this as a choice of which isolated product do I use? You already have the entire platform. Yes, use the whole platform properly. Exactly. You need to respect the strict responsibility boundaries. Power Apps owns the user experience, data verse acts as your governed, shared business context enforcing the rules, and Power Automate handles the orchestration while pushing specialized

compute out to Azure. You have to remember that the control plane, you know, your isolated environments, your ALM pipelines moving from rehearsal to opening night, your DLP policies, and your overarching security matters just as much as the applications themselves. Without a doubt. You simply cannot build enterprise software without an enterprise grade control plane. Absolutely spot on. So as we wrap up this deep dive, I want to leave you with a final thought to ponder that builds on everything we've talked about today. Okay, let's hear it. Think about what happens when an enterprise inevitably discovers that their legacy workflows

are actually built like massive, unmaintainable model X hidden inside single-candice apps. All the logic, all the heavy data processing, all tangled directly in the UI layer. And now leadership decides they want to modernize those chaotic apps by just slapping an autonomous AI agent on top of them. It is a ticking time bomb for support engineers to untangle. It really is a looming storm for support teams everywhere. You've been listening to Support Engineering Weekly from the Support Engineering Blog. For the full articles, references, and technical resources from today's discussion, visit the

URL blog.sadhan.ch. Until next week, keep troubleshooting, keep learning, and keep engineering. Thank you for listening to Support Engineering Weekly. This podcast is available on Spotify, Apple podcast, YouTube, and other major podcast platforms. Follow the show on your preferred platform and never miss an episode.

Open the transcript file

Hosts and Guests

Nobody is credited on this episode yet.

Credit the people on this episode

Be the first to rate this episode

More episodes

All episodes
  1. Microsoft Weekly — November 16-20, 2026

    Nov 20, 202656 minAudio

    What happens when a routine network maintenance operation triggers a failure deep inside a cloud provider's authentication infrastructure? In this week's episode, Alex and Maya investigate how a seemingly isolated...

    Credit the people on this episode

  2. When Redundancy Fails: Inside Microsoft’s Network Stampede

    Nov 17, 202633 minAudio

    How can a routine network capacity upgrade trigger a global cloud outage - and why can the very systems designed to protect availability make the failure worse? In this Support Engineering Weekly bonus episode, Alex and...

    Credit the people on this episode

  3. From Microsoft Announcement to Completed Change

    Nov 15, 202623 minAudio

    Microsoft 365 administrators deal with information from several places: the Microsoft 365 Roadmap, Message Center, and Service Health. But knowing where to find an update is only part of the challenge. The real question...

    Credit the people on this episode

  4. Microsoft Weekly — November 09–13, 2026

    Nov 13, 202623 minAudio

    A server under pressure fails its health checks. Automated traffic management removes it from service, pushing even more load onto the remaining infrastructure. What was designed to protect the system becomes part of...

    Credit the people on this episode

  5. Planner Premium Isn't Project Online — So What Is the Gap?

    Nov 8, 202621 minAudio

    Microsoft Project Online is approaching retirement - or, in this case, its retirement date has already passed. But replacing a project management platform is not as simple as moving tasks from one product to another. In...

    Credit the people on this episode