Power Apps Canvas Apps Fundamentals Training

Canvas apps in Microsoft Power Apps let you build your custom business applications without traditional coding. Instead of writing so much extensive code, you design your very own app by simply dragging and dropping UI elements onto a canvas and use Excel-like formulas (Power Fx) to add in your logic. This beginner-friendly free Power Apps training guide overview on Canvas Apps and Power Fx might cover the initial fundamentals of canvas apps and provide a few tips for you on key topics to look for covered more in depth in our power platform fundamentals training in canvas apps such as managing collections, using galleries, handling button actions, and understanding data sources (Dataverse vs. SharePoint and delegation).

Along the way, we may highlight resources from Microsoft Learn and official docs to help you start improving your Power Apps skills, but the better fast track way when Learn is not enough is Instructor Led Power Apps canvas apps fundamentals training  with Dynamics Edge when wanting to go beyond the what canvas apps are and want to go more into how to succeed with them with the use of Power Fx and much more.

What Are Canvas Apps in Power Apps?

Canvas apps are one of your app types with Power Apps canvas apps training that give you a “blank canvas” to design your own interface and user experience from scratch. You can place screens (views) and add various controls (like text inputs, dropdowns, galleries, buttons, etc.) onto those screens. You have full control over the layout and can make the app look and feel the way you want for phones, tablets, or web.

Key characteristics of canvas apps:

• No heavy coding required: Instead of writing code in your more complex heavy languages like C# or JavaScript, you use Power Fx formulas, which might feel much easier and more familiar to you as they may be more similar to Excel formulas, to define your own app’s behavior. For example, you might write your formula to filter data for a gallery or to update a value when a button is clicked.
• Drag-and-drop design: Power Apps provides a visual designer. You simply drag UI components onto the canvas and position/size them as needed. This makes it easy for those without programming experience to build interfaces.
• Connect to many data sources: Canvas apps can connect to hundreds of data sources (via connectors) – from Excel and SharePoint lists to SQL databases and Dataverse, as well as third-party services. This means you can pull in business data from where it lives and create interactive apps on top of it.
• Run on multiple devices: Once built, you can share your app for others to run in a web browser or on mobile devices. Canvas apps can also be embedded in services like SharePoint, Teams, or Power BI for convenient access.

Why use Canvas apps? They are so great for quickly creating custom solutions (like expense trackers, contact managers, field service forms, etc.) that are tailored to your organization’s needs. Your Power Apps training for canvas apps fundamentals can cover all this for you without needing professional developers, just a basic understanding of formulas and design, so that even “citizen developers” like you can go right ahead and turn an idea into a working app.

Designing your App: Screens, Controls, and Power Fx Logic

When you start a canvas app, you usually would create one or more screens (pages in your app) and add controls onto them to build your user interface. For example, you might have a Browse Screen with a list of items, a Detail Screen to show item details, and an Edit Screen with a form to input new data. Power Apps can even auto-generate a basic three-screen app from data (for instance, from an Excel table or SharePoint list) which you can then customize.

Adding and configuring controls: Power Apps offers you with many types of controls (text input boxes, dropdowns, toggles, images, buttons, charts, etc.). You can add a control from the insert menu and then set its properties. Each control has properties like Size, Color, Visible, Default, and so on, which you can configure. Some properties you set directly (e.g. a Label’s text), and others you set with formulas to make the app dynamic. For example, you might set a label’s Text property to a formula that concatenates other values or to show something conditionally.

Power Fx – the formula language: Canvas app logic ends up usually being defined using Power Fx, which uses a syntax and functions much like Excel. You tend to write formulas in the formula bar so you can tell your app what to do. For instance, you might use a formula to filter records, as well as to update variables, or navigate between screens. Power Fx is declarative, meaning the formula defines the desired outcome of a property. Some common formula examples:

• Setting the Items property of a gallery to show only active items:

  Filter(Projects, Status = "Active")
  

  This would make the gallery list only the projects where Status is “Active”.

• Using an If formula to control visibility:

  If(Dropdown1.Selected.Value = "Other", true, false)
  

  This could be put in a component’s Visible property to show a field only if the dropdown selection is “Other”.

Tip: Power Fx formulas can reference control values (Dropdown1.Selected.Value), global or context variables, and leverage a large library of functions (text functions, math, date/time, etc.). Microsoft provides a full formula reference listing all Power Fx functions and their usage. While it can be a great resource as you start writing more complex logic, Dynamics Edge Instructor Led Training (ILT) in Power Apps Canvas App Fundamentals in Power Platform can help you where this guide might be too overwhelming or unclear so you can start leveraging Power Apps Canvas Apps for your Dataverse integrations fast and soon.

App design considerations: Since you have complete freedom with canvas apps, it’s good to follow some design best practices even as a beginner. Plan your screens so the app flows logically. Keep the UI clean and user-friendly – for example, use forms for data entry (they provide a structured way to edit or view a record) and use consistent formatting for fonts and colors. Power Apps has features like containers and relative positioning for responsive design if needed, but to start, focus on getting the functionality working, then refine the layout. The official docs have a section on designing the UI and controls, which you can consult for more tips on organizing screens, using themes, and making an accessible app.

Using Collections for Temporary Data Storage

As you build apps, a common need is to store or manipulate data within the app (for example, caching data from a source, storing user selections, or building a list in memory). This is where collections come in handy. A collection in Power Apps is essentially an in-memory table of data that lives only while the app is running. You can think of it as a temporary list or mini-database within your app. Each collection can hold multiple records (rows), and each record can have fields (columns) just like a table.

What are collections useful for? Collections are very flexible and serve many purposes for app makers:

• Caching data for offline or performance: You can load data from an external source (like a SharePoint list or Dataverse table) into a collection once, and then the app can use that local copy repeatedly without additional calls. This improves performance and even allows offline usage. Essentially, collections act as in-memory tables that hold data temporarily within the app. For example, an app could collect a list of products into a collection on startup so that searching/filtering those products doesn’t require constant server queries.
• Storing user input or intermediate results: If your app has a multi-step form or wizard, you might collect inputs into a collection as the user goes, and then save them all at once at the end. Or if a user selects multiple items (like checkboxes in a gallery), you could collect those items into a collection for further processing (e.g., batch delete or update).
• Manipulating or aggregating data: Collections let you manipulate data locally. You can filter, sort, add, or remove records in the collection without touching the source data until needed. This is great for scenarios like building a “shopping cart” in-app or preparing a batch of changes to send to the data source in one go (batch update). Developers often use collections for batching updates – gather changes in a collection, then use one operation to write them to the back-end, reducing multiple calls.

Creating and using a collection: In Power Fx, you typically use the Collect or ClearCollect functions to create or update collections. For example:

// Create a new collection or add records to it
Collect(SelectedProducts, ThisItem)

This formula, when used (say, in a gallery item’s checkbox OnCheck), would add the current item (ThisItem) to a collection named “SelectedProducts”. If that collection didn’t exist yet, it’s created on the fly. Each record in SelectedProducts would have the same fields as the items in your gallery’s source.

Alternatively:

// Create or refresh a collection with a filtered dataset
ClearCollect(OpenProjects, Filter(Projects, Status = "Open"))

This uses ClearCollect to wipe any old data in the OpenProjects collection and load it with all records from the Projects data source where Status is “Open”. ClearCollect is handy to refresh a collection with new data without accumulating duplicates.

Once you have a collection, you can bind controls to it. For instance, you could set a gallery’s Items property to SelectedProducts to show those items, or use a collection as the data source for a form, etc. You can also inspect collections during development by using the Variables pane in Power Apps studio, under the Collections tab (this lets you see the contents of each collection while testing the app).

Important: Data in collections is temporary. It’s stored in the app’s memory and is cleared when the app is closed (unless you explicitly save it to something like local device storage or a data source). Collections are not a replacement for a proper database if you need persistent storage – they are meant for transient scenarios. If the app is closed or restarted, the collection starts empty again (unless reloaded).

Managing collections effectively – best practices: While collections are powerful, you should use them wisely. Here are a few tips to keep your app running smoothly:

• Avoid extremely large collections: Don’t blindly load tens of thousands of records into a collection. Huge in-memory tables can bloat your app and slow it down or even hit memory limits. Only collect what you need. For large datasets, consider filtering at the source or using delegation (see delegation section below) instead of pulling all data in. In short: use collections to cache relevant data, but not to hold an entire massive database. As a guideline, keep collections to a reasonable size to maintain performance.
• Clear out data you no longer need: If a collection is used for intermediate calculations or steps, you can clear it when done using the Clear() function. For example, if you collected search results into a collection, you might clear it when the user resets the search. This frees up memory during the app session.
• Use ClearCollect rather than repetitive Collect: If you’re updating a collection with new data from a source periodically, ClearCollect helps avoid piling up old data. It replaces the content each time. On the other hand, Collect keeps adding (which is fine for accumulating unique items, but not for refresh scenarios).
• Be mindful of delegation with collections: If you collect directly from a data source with no filtering (e.g., Collect(MyCol, SharePointList)), Power Apps will only pull a limited number of records due to delegation limits (more on this below). To avoid missing data, ensure your Collect or ClearCollect is either on a small data source or uses delegable queries, or use methods to overcome limits if necessary.
• Document your collections: Especially as apps grow complex, keep track of what each collection is for. Maybe name them clearly (e.g., colSelectedItems or colTempResults) and consider adding comments in your formulas. This helps with maintainability when you or others revisit the app later.

By using collections thoughtfully, you can significantly improve your app’s responsiveness and capability. They act as the app’s “working memory” for data. Just remember that any data in a collection will need to be explicitly saved (with a Patch, flow, etc.) if you want it in a permanent location outside the app.

Displaying Lists of Records with Galleries

To display lists of data in a user-friendly way, Gallery controls are commonly used in canvas apps. A Gallery shows a scrollable list of records or items, where a template defines how each item looks (for example, each row might show a name, an image, and a subtitle). According to Microsoft’s documentation, a gallery is a control that “shows a list of records that can contain multiple types of data.” In practice, this means you can have text, images, icons, and other controls inside a gallery item layout to present each record’s information.

Using a gallery: When you add a Vertical (or Horizontal) Gallery to your screen, you typically set its Items property to a table of records. This could be a direct data source (like a SharePoint list, Dataverse table, etc.), or a collection, or even the result of a formula (like a filtered table). For example, if you have a SharePoint list called Contacts, you might set the gallery’s Items to Contacts (to show all) or a formula like Filter(Contacts, StartsWith(Name, TextSearchBox.Text)) to enable search filtering.

Each gallery comes with a default layout (e.g., image, title, subtitle). You can customize it by selecting the gallery and editing the fields shown. Power Apps allows you to choose which fields from the data source appear in labels inside the gallery, and you can rearrange or add controls as needed. For instance, in a contacts gallery, you might want to show the contact’s name in bold and their email or phone below it. If the auto-generated layout isn’t ideal, you can change it via the layout menu or manually adjust the controls inside the gallery template.

Galleries do not load all records at once: It’s important for beginners to understand that a gallery (and any connected data control) might not show every record from the data source by default, especially if the data source is large. This is by design – Power Apps optimizes performance by not pulling in huge data sets unless necessary. The concept behind this is called delegation.

• Delegation basics: Power Apps will try to delegate data operations (like filtering, sorting) to the data source (server-side) whenever possible. If you write a formula for the gallery’s Items that can be translated into a query understood by the data source, then the back-end will do the heavy lifting (e.g., filtering 10,000 records to get the 50 that match a criteria), and only the needed results are sent to your app. However, if Power Apps encounters something in your formula that the data source can’t handle, it will not delegate the query. In those cases, Power Apps will retrieve only a limited set of records (by default 500, can be increased to 2,000) locally and then process the rest of the formula on that partial set. This means if your data source has more rows beyond the limit, those extra rows won’t be considered, possibly leading to incomplete results in your gallery.
• Example scenario: Suppose you have a SharePoint list with 5,000+ items and you set a gallery’s Items to Filter(MyList, Year = 2025). If the = comparison on that field is delegable to SharePoint, Power Apps will ask SharePoint to filter the records server-side and return the matching ones. But if you used a function that isn’t delegable (for example, a complex formula or certain unsupported functions), Power Apps might only fetch the first 500 records of MyList and then filter those on the device. If the matching item was record #600, it wouldn’t appear because it never got retrieved. This is why sometimes you might notice a gallery only showing the first set of records and not everything – it’s often due to a delegation issue. The Power Apps studio will usually warn you with a yellow triangle and a blue underline in the formula bar if something isn’t delegable, to alert you that results may be incomplete.
• Why this is important: For small data sources (under 500 records), you might never notice a difference – any formula will work because Power Apps can just handle data locally if needed. But once apps scale to larger datasets, not understanding delegation can lead to apps that appear to work in testing (with small data) but fail or show wrong data in production (with lots of data). It’s crucial to know which data sources and functions support delegation. Microsoft’s documentation provides lists of delegable functions for each data source (e.g., which operations can be delegated to SharePoint vs Dataverse). As a quick example, Dataverse supports a broader set of delegable queries (including the in operator, certain lookups, etc.) than, say, an Excel data source. SharePoint supports many delegable functions (like basic filters and sorts), but not all (for instance, filtering on calculated columns or using the StartsWith on multi-line text may not delegate).

How to work with delegation: As a beginner, start by designing your galleries and data access with the assumption that you shouldn’t need all records at once. If you do need to show a large list, try to load data in chunks or force the user to filter/search so that you narrow down the dataset. Always heed the delegation warning hints in Power Apps studio – if you see one, consider altering your formula to a delegable one or switch to a more capable data source if needed. For example, instead of using a non-delegable function, see if there’s an alternative (use StartsWith instead of Left when filtering text, since StartsWith is delegable for many sources). And if you truly need to pull more than 2,000 records and can’t delegate (not recommended for performance), an advanced method is to use multiple calls or a Power Automate flow to get data, but that’s beyond a beginner scope. The main takeaway: Be mindful that galleries and formulas might not fetch every record unless you structure them to do so properly.

In summary, galleries are your go-to control for lists of items. They make it easy to display sets of data and allow the user to scroll through results. Just remember to use them intelligently with delegation in mind: design your app so that the gallery is showing the relevant subset of data at any given time, rather than attempting to dump a whole database on screen. This approach keeps your app efficient and user-friendly.

Handling User Actions with Buttons (aka “Button Hooking”)

Buttons are one of the simplest but most important controls in any app. A Button control represents a clickable/tappable element that users interact with to trigger actions. In Power Apps, buttons are extremely flexible – you can configure exactly what happens when the user clicks a button by writing formulas in the button’s OnSelect property.

Button basics: You can add a Button control to your canvas from the insert panel. By default, a new button might say “Button” as its text – you can change the Text property to something descriptive like “Submit” or “Next”. The power of buttons comes from the OnSelect property, which defines the behavior when the button is clicked. As Microsoft’s docs put it, you configure OnSelect of a Button to “run one or more formulas when the user clicks or taps the control.” In other words, a button’s click can trigger any action that you can express with Power Fx formulas – from navigating to another screen, to updating variables, to writing data, to calling a flow.

Common uses of buttons in canvas apps:

• Navigation: Perhaps the most common action – moving between screens. For example, a “Next” or “Details” button might use the Navigate() function. A formula like Navigate(DetailScreen, ScreenTransition.Fade) would take the user to the DetailScreen with a fade animation.
• Submitting or saving data: If you have an Edit form control on the screen (bound to some data source), a “Save” button could call SubmitForm(EditForm1) which attempts to save the form data to the source. Or you might use Patch() or Collect() inside OnSelect to manually send data. For example, a “Add to Cart” button might Collect(CartItems, ThisItem) to add the current item to a collection.
• Updating variables/state: Buttons often set variables that drive app logic. For instance, clicking a “Filter” button might UpdateContext({ShowFiltered: true}) to set a context variable that switches what data is visible. Or a “Favorite” icon (treated as a button) might set a variable or toggles a value. The OnSelect can include multiple steps; you can separate multiple function calls with a semicolon ; (or the double semi-colon ;; which is being introduced as the chaining operator in recent Power Fx updates) to perform several actions in one click.
• Triggering flows or external actions: A button can also trigger a Power Automate flow using the Launch() or custom connectors, to do things beyond the app (like send an email, or write to another system). For a beginner, this is a more advanced use case, but know that it’s possible as your skills grow.

“Button hooking” tips: The term “button hooking” informally refers to hooking up the button with all the necessary formulas/actions. To effectively configure button actions, keep these tips in mind:

• Use the formula bar for the OnSelect property to write your logic clearly. If you find yourself wanting to do many things on one button click, consider if you can simplify or if it should really be split across steps (for maintainability).
• Testing: While in Power Apps Studio, you can test the button’s behavior by holding down Alt (or using the preview mode by pressing F5) and clicking the button. Ensure it performs the expected action.
• If your button triggers something that takes time (like a data submit or flow), Power Apps by default shows a spinner in the top-right to indicate activity. You can also give user feedback via a label or by disabling the button until done, using variables.
• Chaining actions: You can indeed run multiple formulas on one click. For example, suppose we have a form that we want to submit and then navigate back home – the OnSelect could be:

  SubmitForm(EditForm1);; Navigate(HomeScreen, ScreenTransition.None)
  

  This will submit the form and after that, navigate away. The double semicolon ;; (or a single ; in classic syntax) separates two actions. The order matters: here we navigate only after submission completes (if the form fails validation, navigation won’t happen). Always plan the sequence of actions intentionally.

To illustrate a simple button formula, here’s an example adapted from Microsoft’s documentation: imagine you have a Text input called Source where a user enters a number, and a Label that shows a running total. You could have a button labeled “Add” with an OnSelect formula:

UpdateContext({ Total: Total + Value(Source.Text) })

When the user clicks “Add”, this formula will update a context variable named Total by adding the number the user entered (after converting the text to a value). The label could be bound to Total to display the updated sum. This demonstrates how a button can trigger a calculation and store the result – all with a one-line formula on its OnSelect.

Another everyday example: a “New Item” button that should clear a form and go to a new screen might have:

NewForm(EditForm1);; Navigate(EditScreen, ScreenTransition.Cover)

This resets the form for new entry and then navigates to the screen where the form is.

Styling and properties: Beyond OnSelect, buttons have many appearance properties (color, hover color, disabled state, etc.) which you can also control via formulas or static settings. For instance, you might set a button’s DisplayMode to Disabled if certain conditions aren’t met (like the form is not filled out), providing a visual cue that the user must complete something before clicking.

In short, Buttons are the triggers for your app’s interactive logic. Make sure to label them clearly (text should reflect the action like “Submit”, “Delete”, “Next”, etc.) and test that each button does what you expect. With formulas, you can make a single button perform very powerful operations in your app. As you get more advanced, you’ll even create component libraries of pre-styled buttons or use icon buttons, but at the fundamental level, mastering the OnSelect formula of a button is key to making your app actually do things when users interact.

Working with Data Sources: SharePoint vs. Dataverse (and Why Delegation Matters)

Besides the canvas and controls, the choice of data source is a crucial aspect of Power Apps development. Two very popular data options for canvas apps are SharePoint Lists and Dataverse. As a beginner, you might start with SharePoint because it’s readily available if you have Office 365. As your apps grow in complexity and data volume, you might consider Dataverse, which is the power platform’s native database service. Let’s compare these and see how they relate to performance and delegation:

SharePoint Lists as a data source: SharePoint has long provided list functionality to store data (think of rows and columns in a list, similar to an Excel table but on a SharePoint site). Many Power Apps are built on SharePoint lists because they are easy to use and included in many Office/Microsoft 365 plans (no extra cost). For a simple app or small dataset, SharePoint works great. It’s common to use SharePoint for things like tracking tasks, contacts, requests, etc., with maybe up to a few thousand items. In fact, SharePoint lists can comfortably handle up to around 100,000 rows of data for typical uses, making them a solid starting point for many apps. And since it’s essentially free (comes with your O365 subscription), it’s very attractive for organizations not ready to pay for premium services.

However, SharePoint is not a full-fledged database. It has some limitations that one should be aware of:

• Delegation limits and performance: SharePoint connector in Power Apps supports delegation for many operations, but you can still hit limits. There’s a well-known 500 (or 2000) item limit for non-delegable queries, and SharePoint itself has a 5,000 item threshold in views (though that’s managed behind the scenes by Power Apps). If your app tries to pull a lot of data or do complex filtering on a huge SharePoint list, you might encounter those delegation issues we discussed. Many app makers have run into the scenario where a SharePoint list beyond 2000 items becomes tricky to work with in Canvas apps without careful planning. You can still use SharePoint for larger lists, but you have to design around the limits or use workarounds (like using collection techniques, or splitting data, or leveraging Power Automate as an intermediary).
• Relational capabilities: SharePoint lists can have lookup columns and some relationships, but they are relatively basic. If you find yourself needing many connected lists (like one list of Orders, another of Customers, etc., with complex relationships), SharePoint can become cumbersome. It’s not designed for deep relational data modeling.
• Security model: SharePoint does allow item-level permissions, but it’s fairly limited compared to Dataverse. If you need row-level security at scale, SharePoint might get hard to manage (unique permissions on many items can slow things down, and users who get a link might navigate to list views unless you lock it down carefully).

Dataverse as a data source: Microsoft Dataverse (formerly Common Data Service) is a cloud database for Power Apps and related services. It is more robust and feature-rich than SharePoint for building business applications. It’s essentially a managed relational database system behind the scenes, with lots of extras like auto-generated forms (Model-driven apps), business rules, advanced data types, and enterprise-grade security. Here are some key points about Dataverse:

• Scalability and delegation: Dataverse is built to handle large datasets and complex queries efficiently. In Power Apps, Dataverse generally supports delegating a wider range of queries (for example, the in operator is supported by Dataverse but not by some other sources like Excel). This means you are less likely to hit the 500-record limit as long as you use delegable formulas. A user on the Power Apps forum summarized it well: Dataverse is far more scalable than SharePoint and essentially eliminates the 5,000 item limit issue, allowing you to work with larger data sets without worry. If your app deals with tens or hundreds of thousands of records, Dataverse is a better choice to ensure good performance and correct results.
• Relational data and advanced features: Dataverse allows you to create relationships between tables (one-to-many, many-to-many) easily, and to enforce things like required columns, unique values, and referential integrity. You can also define business logic on the data level – for instance, calculated columns, rollup summaries, or business rules that enforce conditions across fields. These things are either impossible or manual in SharePoint. If your app is more business-critical with complex data, Dataverse is likely the way to go.
• Security: Dataverse has a very granular security model. You can set up security roles and field-level security, and even row-level security using business units and role assignments. In SharePoint, if you wanted to restrict certain records, you’d often need separate lists or complicate your app logic. In Dataverse, it’s built-in – for example, you can say only managers see certain records, etc., and the platform enforces it across all apps.
• Integration and ecosystem: Because Dataverse is part of the Power Platform, it integrates well with Power Automate, Power BI, etc. You can easily create dashboards or reports on Dataverse data (and it’s optimized for that). Also, Dataverse is the storage behind Model-driven Power Apps and many Dynamics 365 applications, so it’s a proven enterprise platform. For example, you could use Dataverse and later decide to also build a Model-driven app or a portal on the same data – not something you can do with SharePoint lists.

Licensing and cost considerations: It’s worth noting that Dataverse is a premium feature. While you can use SharePoint with just a standard license, using Dataverse typically requires a Power Apps Per App or Per User plan (unless you are using the limited Dataverse for Teams within Teams environment). This is why many beginners start with SharePoint – it’s already available without extra cost. If you move to Dataverse, ensure you have the proper license and be mindful of storage capacity (Dataverse has capacity limits, which can incur additional costs if you need a lot of storage). In contrast, SharePoint storage comes as part of your SharePoint/OneDrive storage in Office 365.

When to use which? In summary:

• SharePoint Lists are great when your data is simple, your volume is moderate, and cost is a big factor. For a small organization or a simple app (a few lists, each maybe under 50k items), SharePoint is often sufficient and very accessible. It’s a good starting point for Power Apps learning and smaller scale solutions.
• Dataverse is ideal when you need to scale up – for business-critical apps, complex data models, larger data volumes, or high performance requirements, and when you need advanced features like row-level security or tight integration with other Dynamics/Power Platform tools. If your app may grow or be used widely across an org, investing in Dataverse can pay off with better reliability and performance (at the expense of added licensing). As one Power Apps community member succinctly put it: “SharePoint is not a database” – meaning if you need true database capabilities, you should use a true database like Dataverse or SQL.

Delegation advantages with Dataverse: To directly address the delegation point – because Dataverse can handle queries server-side more effectively, you can avoid the pitfalls of partial data. For example, filtering on columns, doing “starts with” searches, or lookup by related entities – many of these things delegate nicely with Dataverse whereas with SharePoint you might hit limitations or have to simplify the query. This allows your canvas app to retrieve exactly the records needed from possibly tens of thousands, with no 500/2000 limit concerns (aside from the fact that Dataverse itself can return up to 100k in a single query by default, which is usually enough). This doesn’t mean you should throw huge data sets unfiltered into a gallery – you still design for performance – but Dataverse gives you more headroom and flexibility for data-heavy apps.

Bottom line: Use the data source that fits your scenario. If you’re prototyping or doing something quick for a team, a SharePoint list might be perfectly fine (and quick to set up, since many are familiar with it). Just remember the delegation considerations (maybe keep the item count reasonable or queries simple). If you find your app is hitting limits or you need more sophistication, Dataverse is the path forward. And if you do plan from the start that your app requires relational data or could grow significantly in usage, starting with Dataverse can save headaches down the line. Microsoft Learn and docs have more detailed guides on connecting to data sources, delegation, and choosing the right data source for your Power Apps project.

Tips to Continue Learning

Becoming proficient with Power Apps Canvas apps and Power Fx is a journey. Microsoft provides excellent learning resources that you should absolutely take advantage of but when these are not enough, Dynamics Edge instructor led training on Power Platform may be the faster, more in depth, and better way:

• Microsoft Learn Modules: Microsoft Learn is a free, self-paced learning platform with curated modules and learning paths for Power Platform. For example, there’s a beginner-friendly module called “Get started with Power Apps canvas apps”. This module walks you through the basics of why Power Apps is useful, and it even has exercises like creating your first simple app from data. Following such guided exercises can rapidly build your understanding. Other useful modules for beginners include “Create a canvas app in Power Apps”, “Use the UI and controls in canvas apps”, and “Get started with Power Fx”. Each module typically mixes explanations with hands-on tasks you can follow in your own Power Apps environment.
• Official Documentation and Guides: The Power Apps documentation site (learn.microsoft.com for Power Apps) is a comprehensive reference. It has conceptual overviews, how-to guides, and best practices. For instance, you can find docs on almost every topic we covered: galleries, forms, variables, delegation, etc. The docs often include examples and formula snippets. If you’re wondering “How do I do X in Power Apps?”, the docs likely have an article or section on it. The documentation is organized into sections like Get started, Create a canvas app, Design the interface, Understand building blocks, Advanced techniques, etc., making it easy to navigate topics.
  • There is a Power Fx formula reference listing all functions and their usage. This is incredibly handy when you start writing formulas and want to learn new functions or the exact syntax.
  • There’s also a controls reference that lists all properties of each control (for example, all the properties of a Button or Gallery control). This can help you discover what you can do with a control.
  • The docs include troubleshooting sections like common issues (for example, if you run into an error or something not showing, you might find it in the FAQs or issues doc).
• Community and Forums: Microsoft Power Apps has a strong community. The Power Apps Community Forum (powerusers.microsoft.com) is a place where you can ask questions and see solutions that others have posted. Often, if you get stuck, a quick search there (or on Stack Overflow or Reddit’s r/PowerApps) can find answers from people who faced similar issues. Just remember to be cautious with copying solutions blindly; make sure you understand and test in your scenario. When still stuck even so, Dynamics Edge Power Platform fundamentals training in Power Apps Canvas Apps can help you more in depth on issues that you might either not have the time, are confusing, or may not even be addressed at all in the community but our professionals may know how to help you!
• Practice and small projects: Lastly, the best way to get better is to practice building apps. Start with small useful apps – maybe something for personal use or a manual process you can simplify at work. Each mini-project will teach you something new. Microsoft Learn often provides sample data or scenarios to try. Also, consider exporting and dissecting templates: Power Apps comes with some sample templates and there are galleries where the community shares apps. Opening these can be educational (see how others structure their apps, how they write formulas).

Staying updated: Power Apps is part of a rapidly evolving Power Platform. New features (and new Power Fx functions) are added frequently. Keep an eye on the official Power Apps blog for announcements of new features. The docs also have a “what’s new” section. By staying curious and using the resources at hand, you’ll continuously improve your canvas app and Power Fx skills.