Welcome to the M365 FM podcast, where we explore the people, ideas and technologies shaping the future of work. Why these three words make power apps feel harder than it is. Most people open power apps see screens, galleries, and forms, and close the tab. The words sound like a language you were supposed to learn somewhere else. But there are just three simple ideas wearing technical names. A screen is a page. A gallery is a list of your records, and a form reads or changes one of them. Stick with me and those three words stop being noise and start being a map. Power apps is Microsoft's tool for building small business apps without writing code, and almost every tutorial jumps straight into those three words as if you already know them. So we're going to slow down and name them properly because once you can name them, every beginner tutorial after this one starts making sense, the pattern that trips people up goes like this. A tutorial shows you a finished app, points at a list on the screen, and calls it a gallery, without ever explaining that a gallery is just your data laid out in rows. Then it points at a set of boxes, calls it a form, and moves on. You nod along and nothing sticks because nobody told you. The three things work as one system. A screen holds the gallery and the form. The gallery shows your records and the form opens the one you picked. There's also a real limit buried in all of this, one that silently hides your data and fools almost every beginner. We'll get to it before the end, and it's the single most useful thing to know before you build anything. What does screen really is? A screen is one page of your app, and that's the entire definition. When you open PowerApps and start a new app, you get a blank page and that page is a screen. If your app needs three pages, you add three screens. And if it needs one, you use one. You decide which screen appears first by setting a value called the start screen. PowerApps opens the first screen in your list unless you tell it otherwise, and pointing that setting at a different screen takes about five seconds. That matters more than it sounds, because the first thing a user sees decides whether they trust the rest of the app. Moving between screens takes a single function called navigate, and you attach it to a button or an arrow. Tell navigate which screen to open, and that's the whole job going back as a separate function called back, which returns the user to wherever they came from. So the navigation layer of a beginner app is really just two words. Power apps also ships with ready made screen layouts, which means you rarely start from nothing. There's a welcome screen, a screen with a header, and a gallery, one with a header and a form, one with a header and a table and a screen built for approval requests. You pick the layout closest to what you want and adjust the pieces inside it. So picture a phone app with a list, a detail page, and an edit page. That's three screens and two arrows. And that's the whole structure. Nothing is hidden and nothing is waiting to surprise you. One practical habit follows from this. Phone screens are small, so the apps that feel good usually give each screen a single job. You browse on one screen, read on another, and edit on a third. When people try to cram all three onto one phone screen, the app gets crowded and the user gets lost. What makes screens easy to underestimate is how much they can hold. A screen isn't a fixed template with slots you have to fill, because it's a blank surface where you can place text, images, buttons, lists, and forms wherever you like. That freedom is why Power Apps feels more like drawing than programming, and it's also why beginners sometimes build the same thing five different ways before they find the one that fits. And that freedom is the first hint that a screen is only a container, which means the real work starts with what you put on it. What a gallery really does. A gallery shows many records at once, and by records I mean rows of your data. If your data lives in a SharePoint list of company laptops, each row is one laptop, and the gallery turns those rows into a scrollable list. On the screen, the gallery asks you one question, and that question lives in a property called items. Point items at your data source, and the gallery fills itself with rows. Change the source and the list changes with it. For a beginner, this is the moment PowerApps stops feeling abstract because you watch your own data appear on a page you drew. A gallery works from a template, which is the first row it draws. That first row is the mold for every row. After it, move a label inside the mold and every row moves with it. Change the color of the mold and all the rows change color at once. This is why beginners who edit one row and expect the others to stay put get confused because the gallery is treating that first row as the blueprint for everything below it. You also get a few layouts to start from a vertical gallery stacks rows down the screen and a horizontal gallery runs them across. There's a flexible height version for rows that need different sizes, though Microsoft warns it can jump around if someone scrolls before the data finishes loading. The item's property is also where searching and filtering happen. If you want a search box above the gallery, you point items at a formula that filters your data as the user types, and the gallery redraws itself on every keystroke. That sounds advanced, and it's really one line, which is the point of a gallery. It handles the boring part of showing many rows, so you can focus on what each row should say. Then there's the small detail that makes the whole system work. When a user taps a row, the gallery remembers that row as its selected item. Nothing appears to happen on screen, and it looks like the tap did nothing at all. But that selection is sitting there waiting for the next screen to pick it up. And that's exactly what the form does next. Remember that word selected because it's the hinge the entire app swings on. What a form really does. A form handles one record at a time and it comes in two flavors. The display form shows many or all of the fields of a single record, and it stays read only so nobody can change your data by accident. An edit form does the opposite, letting someone change a record or create a new one and save those changes back to your data source. Both forms are built from cards and each card is tied to one field. You get a card for the laptop. Name, a card for the owner, a card for the purchase date. When you tell the form which data source it belongs to. PowerApps learns the field names, the data types, and which fields are required, and it uses all of that to keep the data honest. One single edit form can wear three hats, which surprises most beginners. New form puts it in create mode and clears the field so someone can start fresh, while Edit Form puts it in edit mode and fills it with the record you selected. View form locks it down for reading and submit. Form says whatever the user typed. If someone changes their mind, reset form throws those changes away. So a form isn't three separate things you have to build. It's one control and you tell it which job it's doing right now. That's the whole trick. And it's why a generated app can hand you create, edit, and view from what looks like a single screen. A concrete example makes this. Click. The detail page of a laptop shows every field as plain text. You can't touch. Tap edit and the same fields turn into boxes. You can type in with a save button underneath. Tap save and the form pushes your changes back to the list and drops you on the detail page with the new value showing. There's a built in safety net inside forms, too, because the form knows which fields must be filled in. It won't let a save go through while one of them sits empty, and it can show the user exactly what it's waiting for. You get basic validation without writing any rules yourself, which matters when the people filling in the form aren't the people who built it. If a save ever fails, the form doesn't just swallow it. It holds an error message you can surface on screen and it stays put so the user can fix the problem and try again. That's a small detail, but it's the difference between an app people trust and an app that loses their work. How the three work together in one app. This is where the three ideas snap into one loop, and it's the same loop Microsoft uses when it generates an app for you. You browse for a record, you read it and you change it, and three separate screens carry those three jobs in a single flow. You start on the browse screen, which holds a gallery. The gallery lists your records and the user scrolls until they find the laptop they want. They tap it, and the gallery quietly flags that row as the one in play. Now comes the glue that holds the whole app together. The form on the next screen has a property called item, and you set it to the gallery's selected value. That single line is the bridge between the list and the form, because it tells the form which records the user just picked. If your form ever shows the wrong record or shows nothing at all, the first thing to check is whether that link has come loose. From there, the detail screen shows a display form reading the selected record so the user can review it. If they want to change something, they move to the edit screen, where an edit form holds that same record in edit mode and waits for input when they save the form. Success action runs and you usually tell the app to refresh the data, so the gallery picks up the new value. Microsoft's own generated app does exactly this, which means you can open it, read it, and learn the pattern before you build your own version from scratch. So the whole beginner app collapses into one sentence. A gallery picks a record, a form shows it, and another form changes it. Everything else you add is polished. The nice part is that this loop scales with you. If you need a second kind of record, you add another set of screens and point them at a different list. If you need people to see only their own items, you add that filter to the galleries, items, property, and the rest of the loop keeps working exactly as it did before. What makes this pattern worth learning is how often it repeats. Almost every beginner app you'll build is a variation on it, whether you're tracking laptops, tickets, or people. Once the gallery to form link makes sense, you stop memorizing tutorials and start recognizing the same three moves underneath them, which is when PowerApps gets genuinely quick where this shows up. In real work, the pattern fits any list of things a team already tracks, which is most of them. Microsoft even ships starting points for the common cases, including help desk tickets, employee onboarding equipment, checkout site inspections, and budget tracking. The version beginners actually build is smaller and more useful than that list makes it sound. Maybe your team keeps a SharePoint list of requests, and the built in form is clunky, so people type in the wrong fields or skip them entirely. You swap that form for a friendlier edit screen, and the data gets cleaner without anyone being told to try harder? Or maybe a facilities team walks the building with a clipboard, checking equipment in and out, and the spreadsheet on the shared drive is always a day behind. A phone app built over the list they already keep puts the same data in their hand the moment they touch it, which changes how the work feels. One honest note before you get excited. If the data already lives in a list or a table, you're mostly reshaping a process that exists rather than inventing a new one. That's not a weakness. It's exactly why these apps are quick to build and easy to trust. Because the source of truth never moves and nobody has to learn a new system. You're rearranging what's already there, which is why a first version often takes an afternoon rather than a month. If you're building for yourself rather than a team. The same pattern holds a personal reading list, a home inventory, a habit tracker, or a small client tracker for a side business. All follow the same shape. You keep the data somewhere Microsoft already hosts. You list it in a gallery and you edit it in a form. The scale changes and the loop doesn't. And if you're learning this for your career rather than one specific project, that's the skill worth noticing. You're not memorizing power apps menus. You're learning to look at a messy process and see the list underneath it, which is the same thinking that carries into Power automate, power BI and the rest of the platform. It all sounds straightforward, and there's one limit that turns straightforward into tricky, which is exactly where we're going next. The limits nobody wants you about. Now we get to the part that catches almost everyone and it has a name delegation. You might think the hard part of power apps is the design, but it's actually the data. The idea is simple without the jargon. Power apps would rather send your filter to the data source and let the data source do the heavy lifting, because that's fast and it works on millions of rows. When it can do that, we say the query delegates, but some formulas can't be translated. When that happens, Power Apps stops delegating, quietly pulls the first five hundred records from your data source and finishes the work on the device instead. Five hundred is the default limit. You can raise it all the way up to ten thousand, but the higher you go, the slower the app gets because more data is traveling to the device. And that's why it matters. If your list holds five thousand records and your formula can't delegate, power Apps only ever looks at the first five hundred. Your filter runs perfectly and it runs on the wrong slice of data. Someone searches for a name that sits in row eight hundred, and the app tells them with total confidence that it isn't there. That's the trap, because the app doesn't crash and it doesn't warn the user. It just gives a wrong answer that looks right. Microsoft does leave you a clue, though, and you should learn to spot it. When a formula can't delegate, PowerApps underlines it and shows a yellow warning triangle. Treat that triangle as a stop sign, not a suggestion. Two things keep this from being scary. First, it only applies to big live data sources like SharePoint, Dataverse, and SQL server. Data you imported from Excel or tables you built in memory don't have this problem at all. Second, small lists under five hundred rows are safe because power apps can pull the whole thing to the device and filter it there. None of this means you should avoid power apps. It means you should keep your lists lean. Filter on columns the data source understands, and watch that warning triangle the moment it appears. If your data is genuinely huge and your filters are complex, that's usually the signal to move it into Dataverse, where more of the work can be pushed to the server. Delegation is a design constraint, not a dead end. There are smaller limits worth knowing, too. You can't nest a gallery inside a gallery. Inside a gallery, because two levels is the cap forms and a few other controls. Can't sit inside a gallery at all, and SharePoint column names with spaces show up in power apps as a strange code with x zero zero two zero in it, which looks broken and isn't what it costs and where Microsoft three hundred sixty five and Azure fit in. Start with the good news building is free. Microsoft's developer plan gives you three environments to build and test unlimited apps, and it costs nothing. The catch is that it's for learning and testing, not for real users doing real work. Running apps for real people is the part you pay for power apps premium lists at twenty dollars per user, per month on the yearly plan, and twelve dollars if you commit to two thousand seats or more. Those are US list prices, and they shift with your region and your agreement. So treat them as a starting point rather than a quote. If you outgrow the storage that comes with your licenses, Dataverse capacity is an add on at forty dollars per gigabyte per month. That sounds like a lot until you realize most small apps never come close to touching it. All of this lives inside a stack you probably already have. Power apps is part of the power platform sitting next to Power Automate and Power BI inside the Microsoft three. Sixty five world your team already uses every day. It reads and writes data in SharePoint teams and Dataverse, so you're usually building on top of tools you already have. Instead of adding a new island nobody wants to visit, the Azure side shows up in two places. There's a pay as you go option metered through Azure, which suits work that spikes with the seasons instead of running all year. And if you build copilot studio agents, those need an Azure subscription, which currently comes with two hundred dollars in starting credit. Two more things help you budget without guessing. The premium license includes a small slice of Dataverse storage, so most simple apps pay nothing extra for data, and the pay as you go route builds through Azure by usage, which is a better fit for a seasonal process that runs hard for two months and sits idle the rest of the year. One last distinction saves beginners a lot of confusion. Canvas apps are the ones you draw yourself freeform, and they're where galleries, forms and screens live. model driven apps are generated around Dataverse tables and business processes with a standard look you don't design from scratch. If you're building your first app over a SharePoint list, you want a canvas app, the short version and one question for you. Let's bring the whole map back into one breath. A screen is a page. A gallery turns your data into a list, and tapping a row marks. Which record? You mean your form reads that record or changes it, and a single edit form can create, edit and view just by switching modes. Link the forms item to the gallery's selection and the whole app appears. Browse, read, change. Hold the five hundred row default in your head. Watch for the yellow warning triangle, and you'll sidestep the mistake that trips up almost everyone. That's three words, three ideas, and one loop. And now you can name every part of it. So let me leave you with one question. Think about one list your team keeps the spreadsheet or the SharePoint list that everyone groans about, and picture it as a simple phone app. What's the first list you'd turn into an 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.