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

Power Apps: What Actually Happens Behind the Screen?

Oct 11, 202622 minAudio
ShareXLinkedInFacebookWhatsAppEmail

Power Apps can make application development look simple - but what actually happens behind the screen when an enterprise application runs? In this episode of Support Engineering Weekly, Alex and Maya look beyond the app interface to examine the engineering layers that make Power Apps work in an enterprise environment. The discussion begins with choosing the right application model, including Canvas apps, model-driven apps, Power Pages, and Power Automate. From there, we follow the Power Apps runtime journey - from a user's action and Microsoft Entra authentication through Power FX, connectors, APIs, gateways, data sources, and the response that ultimately reaches the user. We then examine delegation and why a query that works perfectly during development can become a serious scale problem when it encounters production-sized datasets. The conversation moves into security, where application access is separated from actual data access. We explore the layers involved, including identity, environments, application permissions, connectors, roles, records, and column-level controls. The episode also covers auditing, application lifecycle management, Data Loss Prevention, solutions, and managed deployment, showing why production readiness involves much more than getting an application to work. Finally, Alex and Maya examine common enterprise anti-patterns - from non-delegable queries and unsuitable systems of record to excessive privileges, default-environment dependencies, and single-owner production workloads. The discussion also considers service principals, managed identities, licensing, and cost as part of the architecture itself. The central lesson is simple: the app is not finished when it works. It is ready when it can be changed safely. Chapters 00:00 - Power Apps: Behind the Screen 02:14 - Choosing the Right App Model 04:44 - The Power Apps Runtime Journey 07:24 - Delegation, Security, and Scale 12:10 - Auditing, ALM, and DLP 14:48 - Solutions and Safe Deployment 16:17 - Enterprise Architecture Anti-Patterns 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. There's this really fascinating paradox right at the heart of Power Apps. Oh yeah, the speed versus complexity thing. Exactly. On one hand, a maker can just sit down, build a working application, connect it to some data source, and literally solve a massive business problem in what, like an hour? Sometimes even less, yeah. Right. And there's no traditional software stack required, it's just pure speed. But that incredible speed is exactly where the enterprise complexity actually begins.

It really is. Because suddenly, you know, you have this critical business process, maybe it's something handling like regulated financial data. And it's running on an architecture that was basically slapped together in a single afternoon. Which fundamentally changes the stakes. I mean, the time to value is incredible, obviously. Oh, absolutely. But when that little afternoon project suddenly becomes a hard dependency for an entire department, no longer just building an app, you are managing a full blown production workload. And that is exactly what we are getting into today.

So welcome to this special deep dive edition of Support Engineering Weekly from the Support Engineering Blog. I'm Alex, and thank you so much for joining us for this technical discussion. We design these sessions specifically for you really to help you bridge that gap between just building things and actual engineering. And I'm Maya. Thank you so much for being here with us. We are going to be decoding what actually happens behind the screen of a power app today. Yeah, the mission for this deep dive is to move entirely past the question of can power

apps build this? Because let's be honest, the answer to that is almost always yes. Right. Always yes. So we need to tackle the real enterprise engineering question, which is how should this workload be architected so that it's actually secure, performant, and, you know, safely deployable? Exactly. We have to stop treating this as just some low code UI builder. We really do. The application experience, like the actual buttons you tap on your phone or your tablet is just the tip of the iceberg. The real foundation is identity data routing, security boundaries, life cycle management.

All the heavy backend stuff. Yeah, all of it, which means the very first architectural decision you make has absolutely nothing to do with dragging a button onto a screen. You have to start by choosing the right application model for the specific workload. And man, this is where I see a lot of early architecture just completely fail. You shouldn't just open a blank canvas app for every single business problem you run into. No, definitely not. The source material outlines four primary models, right? And that initial choice dictates literally everything else that follows.

So first you have canvas apps. Those are very experienced first. Right. They're built for highly customized specific task based things or mobile experiences. Exactly. You have model driven apps, which operate in a completely different philosophy. Yeah, they are dataverse first. They're ideal for really data heavy, complex, process driven applications. Process driven, yeah. And third, we have power pages, which you deploy when you need a secure external facing web

experience, like a portal. Right. And finally, power automate, which kind of acts as the invisible workflow orchestration layer, just tying it all together, tying it all together. Yeah. I find it really helpful to visualize the fundamental difference between canvas and model driven apps like this. Building a canvas app is like giving an interior designer a completely empty room. Oh, I like that. Right. You control every single pixel, the state of every button, the exact hex code of the background. It is total flexibility. But building a model driven app is more like giving an architect a strict blueprint that's

basically automatically generated by the buildings foundation. It's a great way to look at it. Yeah. You don't control every pixel. Instead, you define your data model in dataverse, you know, the tables, relationships, the business rules. And the platform just uses that metadata to automatically generate the forms and views. The data model literally is the application. And that is the core mechanical difference right there. In a model driven app, the UI is metadata driven. So you sacrifice that, you know, pixel perfect control to gain massive scalability and out of the box relational integrity.

Right. So you choose the canvas app route to get that blank room flexibility mentioned. You are taking on a massive amount of client side and data query responsibility yourself because you have to wire up every single interaction. Exactly. You have to wire it all up yourself, which leads us to something that absolutely blew my mind in this architecture guide. When you do wire up a canvas app and you tap a button to load some data, you aren't just sending a direct SQL pane to a server somewhere. Not at all. You're kicking off this crazy 12 stage runtime journey.

It is a massive orchestration and it's all happening in milliseconds. It starts with the user action on the device. Instantly, the app has to authenticate you. Right. That goes to Microsoft, enter ID to get a session token, just proving you are who you say you are. Once it has that token, it retrieves the apps metadata and runs the initialization logic. The on start stuff. Right. Specifically, whatever you wrote in the on start property. Wait, hold on. So if someone puts a massive data query in that on start property, it basically blocks

the rest of the app from even opening. Exactly. That is a classic performance bottleneck. The app is downloading data, evaluating logic and holding up the entire UI thread before it even attempts to render the first screen. Oh, wow. So the user is just staring at a loading spinner. Pretty much. But assuming it gets past that, the screen finally renders and the app needs to populate say a gallery with data. This is where PowerFX comes in. The app evaluates the PowerFX formula you wrote and generates a specific data request.

But the app doesn't talk directly to the database, right? Like my phone doesn't have a direct line to a SQL server sitting in some data center. No, mobile devices definitely don't have direct database connections. That request is handed off to a connector. Okay. The connector acts as a proxy. It takes the request, applies your authentication context, and routes it through an API management layer or a gateway. So it's traveling quite a bit. Oh, yeah. And that gateway might even transform the request before it finally hits the actual data source,

whether that is Dataverse, SQL database, or some third party API. And then the data source actually executes the query. But the journey back sounds, I mean, just as computationally expensive. It is. The response has to travel all the way back up the chain. It goes from the data source back through the API gateway and hits the connector. Right. Then the connector has to parse that response, which by the way might be a really complex JSON payload into a tabular format that PowerFX can actually understand.

So it's doing translation work too. Exactly. And only then does the client device process that data locally, update the state, and physically redraw the screen so you finally see your records. That is wild. So if an app feels slow, the problem could literally be at any one of those 12 stages. It could be any of them, yeah. It could be the gateway. It could be the connector taking too long parsing the JSON, or even just the device's CPU struggling to redraw the UI. But if we are talking about performance, we really have to talk about delegation.

Oh, definitely. Because if the app is generating all these queries, how does it actually handle massive data sets without melting the phone? The solution is probably the single most important technical concept for Canvas app scalability. The entire goal is to offload the heavy lifting. Okay. Make this server do the work. Right. When power apps can translate a PowerFX formula into a native query that the backend data source actually understands natively, it delegates the work. The filtering, the sorting, the searching, that all happens efficiently on the backend

server. Oh, I see. And then only the specific matching results travel back over the network to the device. Wait, I have to stop you there. What happens if I write a highly custom PowerFX formula? Maybe I'm using some obscure text matching function or something. That a backend SQL database simply does not understand. That's where things get tricky. Does the app just like throw a red error screen in crash? It doesn't crash. And honestly, that is what makes it so dangerous. Really? Yeah.

It currently fails through a mechanism called the delegation limit. If a query cannot be delegated to the server, PowerApps basically falls back to client side processing. But obviously it can't download a million records to your phone's memory. Right. The phone would catch fire. Exactly. So by default, it will only pull the first 500 records from the data source. Oh, wow. You can optionally bump that limit to 2000, but that's it. And then it evaluates your custom formula locally against only that limited chunk of data.

Oh, man. This is the trap. Imagine you are a maker testing an app with like a development data set of maybe 50 records. Yeah, happens all the time. You write a non-delegable query and it works flawlessly because it pulls all 50 records, sorts them locally and looks perfect on your screen. Then you deploy it to production where the actual table has say 50,000 records. Right. The app will silently pull just the first 500 records, run the search, and completely ignore the other 49,500 records.

And it doesn't even tell the user that the data is incomplete, does it? Nope. No warning to the end user at all. That's terrifying. So a canvas app that works with a small data set is absolutely not guaranteed to work correctly at enterprise scale. Not at all. Which means as an engineer, you have to design delegation safe queries from the very first prototype. And you absolutely must test with realistic production data volumes. Okay. Let's assume we avoid the delegation trap. We have a highly performant app and all 50,000 records are flowing seamlessly through those

APIs and connectors we talked about. Okay. Best case scenario. Right. But that creates an entirely new terrifying problem because data is moving so effortlessly down to the client device, how do we ensure only the right people can actually see it? This is a huge shift in thinking. You have to separate the concept of application access from data access. Okay. They are not the same thing. In enterprise architecture, security is a layered model. Giving someone permission to just tap the icon and open the canvas app does not grant

them permission to actually read the underlying data. Ah, okay. Think of it like corporate physical security. Oh, I like this. Microsoft enter ID is basically the security guard in the building lobby checking your ID, right? That just gets you in the front door of the building. Right. Then you have environment access. It determines if you can even get off the elevator onto the third floor where this specific workload actually lives. Exactly. And building on that, application access means someone has explicitly unlocked a specific room for you on that third floor.

Okay. So now I'm in the room. But once you are inside the room, you still need permission to use the tools in there. That is where connector permissions come in. Do you have the right to pass data through that specific gateway we mentioned earlier? Well, so many layers. And I guess the final layer is the data itself. So I'm in the room, but I still need a specific key card to open the filing cabinet in the corner. Yes. That is data versus role based security. You might have access to the cabinet, but you still need record level security to open a specific drawer inside it.

Right. And it goes even deeper. Oh, really? Yeah. The most granular level, column level security, is like needing a special clearance badge just to read a redacted line inside a specific file in that drawer. That's intense. It is. You might be able to see an employee's name and department on the screen, but the salary column is completely locked down at the API level, regardless of what the UI tries to display. And if someone, you know, forces open that filing cabinet or tries to access a column, they shouldn't, that is where the security cameras come in. We are talking about operational evidence.

Yes. Exactly. Because true enterprise security isn't just about blocking unauthorized access, right? It's about proving exactly what happened for compliance and troubleshooting, which means data versus auditing. Data versus auditing, right? Precisely. You enable auditing at the environment and table levels to capture literally every create, update, and delete operation, as well as any privilege changes. So there's a paper trail for everything. Everything. If a regulated workload goes down or if data is modified improperly, the support engineering

team isn't just guessing what happened. They have an immutable audit log showing exactly what the system did and which identity requested it. Okay. So the app is fast, the data is locked down tight, and the auditing cameras are running. The architecture is solid. But what happens on a Friday afternoon when someone decides to just quickly tweak a formula or change a column name? The classic Friday afternoon deployment. Right. How do we ensure the entire workload doesn't instantly break?

This is the transition from just building apps to actually managing software. You need application lifecycle management or ALM. ALM, yeah. When a workload becomes critical, you simply cannot edit it live in production. It's too risky. The very first governance boundary you establish for ALM is environments. And it is so crucial for you to understand that environments are not just folders where you organize your icons. I see that misunderstanding a lot. Me too. So there are hard technical boundaries.

A proper architecture separates workloads based on their lifecycle stage. So you have a development environment, a test or user acceptance environment, and then a totally dedicated production environment. And within those boundaries, you apply data policies, which are commonly known as DLP. So how does DLP actually work under the hood? It's not just a warning message that pops up, right? No, not at all. It is a hard enforcement at the connector level. In your policy, you classify connectors into three buckets, business, non-business, or blocked.

This physically controls where organizational data is allowed to be routed. If you classify Dataverse as a business connector and say a public Twitter connector as non-business, the platform will strictly block any app or workflow from exchanging data between those two connectors in that environment. Wow. So it fundamentally prevents accidental data exfiltration. Exactly. It stops the data from leaking before it even starts. Which is brilliant for securing the perimeter, but getting back to that Friday afternoon update, how do we safely move our tested changes from the development environment into production

without breaking things? That's done through solutions and ALM pipelines. In the power platform, a solution is essentially a container for all your components. In your development environment, you work with what are called unmanaged solutions. Think of unmanaged solutions like raw open source code. You can add tables, rewrite power effects formulas, alter relationships. You can do whatever you want freely. But you definitely don't deploy that raw code straight to production. Exactly. When you deploy the workload through a pipeline to a non-development environment, you export

it as a managed solution. Managed right. A managed solution is essentially compiled and sealed. It creates a layered lock in Dataverse that prevents users from making direct manual edits to those components in the production environment. Oh, that makes so much sense. There is a quote in the source material that perfectly captures this whole mindset shift. The app is not finished when it works. It is ready when it can be changed safely. Yes. I love that quote. Right. Because if you manually tweak a live app in production and accidentally break a critical

business rule, you have no version history, no automated testing, and basically no immediate way to roll back to the previous state. And managed solutions force you to treat production changes as actual governed deployments. And that governed deployment pipeline provides traceability. You know exactly what changed, who approved it, and exactly when it was deployed. Okay. So now, because this is derived from support engineering weekly, we have to talk about the fallout when these principles are ignored. The fun part. Yeah. The guide lists several enterprise anti-patterns.

These are architecture choices that look like brilliant time-saving shortcuts today, but they inevitably become massive, SEVE support tickets tomorrow. Well, we already covered the first major anti-pattern, which is relying on non-delegable queries over large data sets. The silent failure trap. Yeah. The second one we see constantly in support is using SharePoint or Excel as permanent enterprise systems of record for regulated workloads. I mean, I totally understand why it happens. They are incredibly easy to connect to, and almost everyone in an organization already

has a license for them. Oh, absolutely. And they are perfectly valid for lightweight personal productivity scenarios. Sure. But when you build a critical enterprise application on top of a massive SharePoint list, you are setting a massive trap for yourself. You lack true relational modeling. Right. It's just a flat list. Exactly. The delegation limits are much stricter compared to Dataverse or SQL. And you cannot apply that granular column-level security we discussed earlier. Eventually, the workload just outgrows the database architecture and it requires a complete

painful rebuild. Yep. We had to pay in for it later. Another massive anti-pattern is building everything in the default environment. Why is that such a dangerous architectural choice? I see people doing it all the time. It's so dangerous because the default environment is unique. Every single user in the Microsoft 365 tenant automatically has the maker role in it. Wait, everyone? Everyone. And you cannot remove that access. So if you put mission critical, sensitive applications in the default environment, you

have effectively eliminated all your lifecycle boundaries. You cannot easily isolate the workload. You can't apply a stripped custom DLP policy just for that specific app without affecting everyone else in the company. And you cannot properly manage its deployment lifecycle. Well, it is literally the equivalent of running your company's payroll system on a public bulletin board in the break room. That is exactly what it's like. It's terrible. Another anti-pattern is granting broad, data-verse system administrator privileges to users instead of designing custom security roles based on the principle of least privilege.

Oh, yeah. Over-permissioning is a huge headache. But there is one anti-pattern in the source that I think is the most operationally terrifying of all of them, the single owner production dependency. Ah, yes. The lottery factor. Exactly. The lottery factor. So I want you to imagine a scenario where a mission critical legacy workflow, that maybe it's something orchestrating a massive part of a supply chain, was built by one brilliant maker like three years ago. Happens all the time.

Right. And all the connectors, all the API calls are authenticated directly through their personal user account. What happens if that person wins the lottery tomorrow and leaves the company? Or the role changes in IT automatically deactivates their intra-ID account? The entire supply chain workflow instantly fails. Just like that. Just like that. The application completely loses its authorization to access the data sources because it was tied to a human. Critical applications simply cannot depend on a single human being's credentials.

How do you actually engineer around that? What's the fix? The fix is using service principles and managed identities. Okay. The service principle is essentially a non-human identity created specifically for the application itself. You grant all the necessary permissions to the application's identity, not the individual maker's identity. Oh, I see. This ensures that the architecture's ownership is defined at the platform level. So if the original maker leaves the company or gets hit by a bus, the workload just continues to function securely without any interruption.

That makes total sense. We have dissected a tremendous amount of architecture today. I think if you step back and look at the whole picture, the core engineering principle here is actually pretty profound. Build the application around the workload, not the workload around the app builder. Absolutely. When you design for the enterprise, a production workload is really a chain of connected engineering decisions. It starts with selecting the right model, then designing a scalable data structure, securing it in those concentric layers we talked about, deploying it safely through managed solutions,

and ensuring operational visibility through auditing. The UI, the part everyone focuses on, is really just the final mile. It really requires treating power apps with the serious engineering discipline it deserves. And I want to leave you with one final kind of provocative thought that emerges from all of this. Think about licensing as architecture. Oh, that's a good point. All right. The technical design choices you make in the very first hour, which data sources you connect to, which connectors you invoke, and the sheer size of your audience, those fundamentally dictate your eventual cost and licensing model.

Your architecture decisions are directly tied to financial consequences. It's so true. And architecture might be technically flawless. But if your design triggers premium licensing for 10,000 users, when a completely different architectural approach, maybe using a model-driven app, or just a different data routing strategy, could have achieved the exact same business result? That is an engineering failure. True architecture optimizes for both performance and cost. 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 link mentioned in the description. Until next week, keep troubleshooting, keep learning, and keep engineering. Thank you for listening to Support Engineering Weekly. This podcast is available on Apple Podcast, Spotify, iHeartRadio, 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