2026-11-17 · Season 4
Power Apps Canvas vs Model-Driven - Simply Explained

Show notes
Power Apps isn't one tool, and that confusion costs beginners weeks. There are two ways to build an app, canvas and model-driven, and they start from opposite ends. In this episode of Simply Explained you will learn:
- Why Power Apps Feels Like Two Different Tools
- What Power Apps Actually Is
- How Canvas Apps Work
- How Model-Driven Apps Work
- The One Difference That Explains Everything
- The Trap That Bites Beginners With Real Data
- How to Tell Which One You Actually Need
- What It Costs and What Catches People Out
- Where This Fits in Microsoft 365 and Azure
- A Quick Recap and One Question for You
Simply Explained by M365.FM breaks down Microsoft 365, Azure and modern IT topics in clear, jargon-free language. Hosted by Mirko Peters. Become a supporter of this podcast: https://www.spreaker.com/podcast/m365-fm-microsoft-365-azure-cloud-power-platform-ai--6704921/support. This episode includes AI-generated content.
Host: Mirko Peters
Guests
Transcript
Read the full transcript
Welcome to the M365 FM podcast where we explore the people, ideas and technologies shaping the future of work. Why PowerApps feels like two different tools. PowerApps isn't one tool and that confusion costs beginners weeks. There are two ways to build an app canvas and model driven, and they start from opposite ends. You might think it's about how the app looks, but it's actually about where your data lives. Welcome to the M365 FM podcast, where we explore the people, ideas and technologies shaping the future of work. One path gives you total control and the other does the wiring for you. By the end, you'll know which one to pick and the silent trap that bites once your data grows. What Power Apps actually is. Power apps is Microsoft's way of letting ordinary people build business apps without becoming programmers. You don't write code in the usual sense because you assemble pieces, connect them to data, and publish. That part feels friendly enough. The confusing part is that PowerApps doesn't hand you one kind of app, and the two you'll hear about most are canvas apps and model driven apps. Here's the shortest version I can give you. A canvas app starts from a blank screen and you design every part of it yourself. A model driven app starts from your data and the platform builds the screens for you. That's the whole idea in two sentences, and we'll unpack each one in a moment. The name PowerApps covers all of it, which is why the first surprise for most beginners is that there's no single answer to how you build one. There's a version for a quick form, a version for a data heavy process, and separate products for websites and for code. Today we only care about the two that cause the most confusion. Underneath both of them sits something called Dataverse, which is Microsoft's cloud database. Think of it as the place where your tables, your records, and the links between them live with security history and the rules that keep your data tidy built in. Every product in the power platform can use it. One requirement is worth knowing early. A model driven app needs Dataverse, and you can't build one without it because the data model is the whole point. A canvas app doesn't need Dataverse, and it can talk to all sorts of other places, but it works best when there's a solid data home underneath it. So you have two builders, one shared foundation and a choice that plenty of people get wrong on their first project. One of them also hides a limit that can break an app without any warning, and we'll get to that. The next two sections take each builder on its own, and we start with the blank screen. How canvas apps work. A canvas app gives you a blank design surface, and that phrase is exactly right. You drag buttons, boxes, forms, and galleries onto the screen and you arrange them the way you want. If you can picture a layout in your head, you can build it. The data side is just as open. A canvas app connects to data from hundreds of sources, including SharePoint, Excel, Microsoft three hundred sixty five, SQL Server, and Dataverse. That range is the reason people love it, because your app doesn't have to live inside one system. The freedom cuts both ways, and it's worth saying plainly canvas is the right call when the experience is the point. If your app has to look a certain way, or pull a SharePoint list and a weather feed onto the same screen, canvas is where that happens. It's also the gentler place to learn because you see every piece you build. Take a concrete example. Picture a warehouse inspection app. Someone walks the floor with a phone, picks a location from a list, fills in a checklist, adds a photo of anything broken, and tap submit. That whole thing is a canvas app and the person building it is often not a developer. The glue that holds it together is called power FX, which is a formula language written in plain English. If you've ever written a formula in Excel, you already understand the shape of it. You won't need it on day one, but it's where the real power lives. You can also skip the blank page and start from a template, or describe what you want, and let copilot draft a first version for you. Templates exist for common jobs like helpdesk requests, employee onboarding, asset checkout, and budget tracking so you rarely start from nothing. Canvas apps run on windows in a browser and on iOS and Android, so the same app can follow your team from a desk to a loading dock. Now the honest limit because you design everything yourself, you also have to think about phones and desktops yourself. A canvas app is only responsive if you build it that way, so a layout that looks perfect on your laptop can turn into a mess on a phone. It also means there's no safety net if you forget to design for a small screen, or if you skip accessibility, nobody adds it for you later. That trade is the whole personality of a canvas app, and the other builder makes the opposite bargain. How model driven apps work. A model driven app flips the order. You don't start with a screen and you start with your data. You describe your tables, you describe how they relate to each other, and the platform generates an app around that model. Microsoft is blunt about how this feels. Much of the interface is determined for you, and it's decided by the components you add. Those components are familiar building blocks, like forms for entering data, views for listing it, charts for seeing it, and dashboards for pulling it together. Now picture it in practice. Imagine an app for onboarding new employees. You have one table for the people, one for their tasks, and one for their equipment. Because those tables are linked, a user can click from a person to their tasks, to their equipment, and nobody had to hand build those links. Microsoft says model driven apps suit work that follows a clear process and carries a lot of data, and the examples it gives are onboarding, managing a sales process, and member relationships at a bank. If your work is a series of steps across related records, this is the shape that fits. A model is just a picture of your data. You list the things you track, like people and tasks and equipment, and then you describe how one connects to the other. A person has many tasks. A task belongs to one person, and Dataverse remembers those links for you. Once that model is in place, every form and view the platform builds already knows how the pieces fit together. There's a logic layer to a model driven app can walk users through a fixed process with a business process flow, enforce rules on a form without any code, and trigger power. Automate flows for the work that happens behind the scenes. That's a lot of behavior you get by configuring rather than coding. You also get a few things for free that a canvas app makes. You build the design response to different screen sizes automatically. Accessibility features come built in. The look stays consistent from app to app and navigation between related records just works when the relationships exist. Moving the app from test to production is described by Microsoft as relatively simple, because everything lives in one place. Model driven apps even run on mobile and can work offline, which matters when the people using them are out in the field the traders control. You don't get to redesign the header, the navigation or the styling the way you can on a canvas. If your heart is set on a specific look, model driven will feel confining. If you care more about the process than the pixels, it will feel like a shortcut. The one difference that explains everything here is the head fake. The difference between these two isn't about which one looks nicer, and it isn't about which one is newer. It comes down to where you start. A canvas app starts with the screen, and a model driven app starts with the data. Everything else you've heard follows from that one split. When you start with the screen, you get freedom and you take on the wiring. You decide every button and every flow, and you're responsible for connecting the pieces. When you start with the data, you get structure and the platform takes on the wiring. You describe the model once and the app keeps up with it. Microsoft's own comparison makes this concrete on data. A model driven app lives on data verse alone, while a canvas app reaches many sources on control. Model driven gives you limited say over the interface, while canvas gives you full control on consistency. Model driven stays high and canvas is often low because every canvas app is as different as its designer. On responsiveness, model driven adapts on its own, and canvas only adapts if you built it that way. On navigation. Model driven follows your relationships automatically, and canvas follows the formulas you wrote. And this is where it starts to matter for you. When the business changes, a data first app often updates itself because the screens follow the model. A screen first app needs you to go back and move the buttons yourself. If you want one sentence to carry out of this section, make it this one. Canvas apps are for when the experience matters most, and model driven apps are for. When the data and the process matter most. Put plainly, neither one is better. They solve different problems and the cost of getting this wrong isn't a bad looking app. It's weeks spent building something the platform would have built for you. The trap that bites beginners with real data. Now we get to the part that breaks beginner projects in a way you won't see coming. And it has a name. It's called delegation, and it only shows up in canvas apps. The mechanics are simple enough. When a canvas app asks a data source for records, it usually lets the data source do the filtering and returns the matches. That hand off is delegation, and it's what keeps the app fast because the heavy work happens on the server instead of on the phone. The trap is that some formulas can't be translated into a question the data source understands. When that happens, the app doesn't stop and it doesn't warn you in a red box, it pulls the first five hundred records and filters those on the device instead. Five hundred is the default. You can raise that number up to ten thousand records, but Microsoft warns that larger result sets cause performance problems, so the ceiling isn't really a fix. The dangerous part is the silence. You don't get an error. You get wrong results. Microsoft's own example is a data source with ten million records and a filter that can't be delegated. The app only ever looks at the first chunk, so the record you actually wanted may never appear at all. For a beginner, this is the classic story. You build the app, you test it on fifty rows, everything works and you feel great. Then the real list grows past five hundred and the app starts lying to you without ever saying so. Not every data source is equally capable here. Dataverse understands more kinds of questions than Excel does, so the same formula that works against one source can fail against another. That's why the advice isn't to memorize a rule, but to check your specific source. There's a workaround people reach for, and it has its own cost. You can pull the data into the app first and then filter it on the device, which works. But now every user downloads the whole list and the app gets slower as the list grows. Delegation exists to avoid that trade. The fix isn't scary once you know it. Use formulas your data source can understand. Watch for the warning triangle power apps shows you. And while you're testing, Microsoft suggests setting the limit to one so that anything that can't be delegated shows up immediately. And notice the contrast. Because a model driven app sidesteps this whole problem, its data is already server side in Dataverse, so there's nothing to delegate and nothing to miss. How to tell which one you actually need. Choosing gets easier when you start with one question. Ask whether your users are inside your organization or outside it, because that settles most of the decision for this episode. Let's stay inside. If the people using the app are your colleagues, you're choosing between canvas and model driven. And two more questions. Finish the job. Ask yourself about the data first. If your data is complex and relational, if it lives in Dataverse, and if standard navigation between records is what you need, then a model driven app is the natural fit. Think of a sales pipeline with accounts, contacts, and cases that behave like a customer relationship system. That's model driven territory. Now ask about the experience if you need a specific look, or if you need to pull several different data sources into one screen, then a canvas app is the natural fit. Take a field inspection app that reads a SharePoint list, pulls in the weather and needs a branded layout your team will recognize that's canvas territory. One reassurance matters most here, which is that you aren't signing a contract. You can start with a canvas app and grow into model driven later, and you can mix them. Embedding a canvas page inside a model driven app is a normal thing to do when you want a custom screen for one form. If you're learning this for your career, think about what each one teaches you. Canvas apps teach you power effects and the way connectors work. Model driven apps teach you Dataverse and how to model data. If you want the foundation that carries into every other Microsoft tool, learn the data side because it's the harder half and it shows up everywhere. One last practical tip if you're still unsure, build the small version first. A canvas app is quick to mock up, and seeing it on a phone will tell you fast whether the data or the experience is your real problem. You can always rebuild the data heavy part as model driven. Once you know what it costs and what catches people out. Let's talk money, because this is where a fun project turns into a budget conversation. The good news comes first building is free. Microsoft's developer plan costs nothing, gives you three developer environments and includes a small Dataverse allowance to build and test with. The catch is, in Microsoft's own words, building apps isn't charged, but using them is the moment real people need to run your app. In production, you need licenses. And that's the line between a demo and a tool. Your team depends on the main plan. PowerApps premium runs about twenty dollars per user per month when you pay yearly, and it drops to about twelve dollars at very large seat counts. There's also a pay as you go option that runs on Azure, which suits teams whose use goes up and down with the seasons. One rule catches people out the moment your app touches what's called a premium connector, like SQL server, Salesforce, or a custom API, every single user of that app needs a premium license. The smart move is to decide this before you build, not after you've shown it to your boss. The standard connectors, the ones included with most Microsoft three hundred sixty five plans cover SharePoint teams, OneDrive, outlook, and Excel. For a lot of beginner projects, that list is plenty, and it's a good reason to start there. Storage is the other line item. Dataverse capacity comes with your licenses. An extra database space is sold by the gigabyte per month and shared across the company. One honest note before we move on, prices change and they vary by region and agreement, so treat these numbers as the shape of the cost, rather than a quote. That cost is also easier to justify. Once you see where these apps sit inside the tools your team already pays for. Where this fits in Microsoft three hundred sixty five and Azure. Here's why this matters beyond a single app, PowerApps doesn't live on a separate island you have to visit. It sits right on the Microsoft three. Sixty five tools you probably already use. The standard connectors are exactly that idea. SharePoint teams, outlook, and Excel are the systems your team already works in. So a canvas app usually begins with something familiar and extends it. You can drop a canvas app straight into teams or SharePoint, which means the app lives where the work already happens. Instead of in a new tab, nobody opens. Dataverse is the shared data layer under the whole platform. It's what makes a model driven app possible, and it's what ties Power Platform together. So the data you model in one place is available to the rest. Copilot is arriving inside these apps to Microsoft Copilot chat as generally available in model driven apps and still in preview for canvas apps. And it lists the features that let copilot take actions on its own as model driven only. That tells you where the platform is heading and the direction points back to the same advice, which is to keep your data clean and well described. Azure shows up in two ways. Pay as you go. Licensing lives on Azure, and the premium connectors are how an app reaches Azure SQL or an outside service. So the practical picture is simple. PowerApps is the app layer on top of the Microsoft three hundred sixty five and Azure tools you already know, which is exactly why it's worth your time. That also means the skills transfer. Learning how Dataverse models data helps you in power BI, in fabric, and in copilot because they all want the same thing underneath, which is clean Well-described data. A quick recap and one question for you. Let's pull it together. A canvas app starts from a blank screen. You design yourself and it can connect to almost anything. A model driven app starts from your data in Dataverse and the platform builds the screens for you. The choice comes down to your data and your users, not to which one is better. And if you build a canvas app over a big list, watch for delegation. Which one are you going to try first? The blank canvas or the data first app? If this made the topic feel less intimidating, subscribe to M365 FM to master the tools and the mindset shaping the future of work.