Search Content

I feel like just about every commercial app out there has the concept of Export to CSV. Turns out people like to grab their data and open it up in Excel. 🤷 Who Knew. So today, let's walk through how easy it is to add Export to CSV into your Power Apps. Basically, we select some table data, encode it in JSON, and then ship it off to Power Automate which has built in actions to make it super easy. Once the data is in Power Automate you can create a file an then save the file off to SharePoint, OneDrive, send it via an email attachment or basically anything else you can dream of. That is the beauty of flow, once you have the CSV file you can do anything you want. And speaking of Selecting items in a Gallery, we even cover how to Select All and Deselect All in the video version of this. Video: Power Apps Export to CSV with Power Automate Pro Tip:  This tutorial assumes you’ve already got your Power App setup and you’re just focusing on the exporting bit. We’re skipping the app creation part today and heading straight into the exciting stuff: generating a JSON, converting it into CSV, and getting it where it needs to go. Check out the video above if you want to see the app creation and item selection. Creating the JSON from Power Apps First things first, we need to get our data into a JSON format. Power Apps can output data in various forms, but for exporting, JSON is the golden ticket. Step 1: Using the JSON Function In Power Apps, the JSON() function is your new best friend. This function allows you to take any table of data (like the items in your app) and convert it into JSON format. That’s the format Power Automate loves to work with. Here's how to create a JSON variable in Power Apps: UpdateContext({varJSON: JSON(yourTable, JSONFormat.IndentFour)}) This will take your data and turn it into a JSON string, which we’ll use in the next step to create our CSV. Now depending on your table, the previous step might be way more complicated. There JSON function doesn't work against controls or some advanced data types. In the video, we go through all of that but below you can see an example of just how complicated things can get. That is intense, and why the video is a bit longer but that is a good insight of what this looks like in the real world. Parsing JSON in Power Automate Next, it’s time to head into Power Automate. This is where the magic of converting our JSON data into a CSV file happens. Step 2: Parsing the JSON Inside your Power Automate flow, the first step after receiving the JSON from Power Apps is to parse  it. This basically tells Power Automate what data you’re working with and how it’s structured. Add the Parse JSON  action to your flow. Under "Content," insert the JSON data coming from Power Apps. Generate a schema by clicking "Generate from sample" and paste the sample JSON you want to parse. Boom! 🎉 Now Power Automate understands what’s inside your JSON file, and you can start working with that data. Converting JSON to CSV Now that Power Automate knows what your data looks like, let’s convert it into CSV format. Step 3: Create CSV Table Action We’ll use the Create CSV Table  action in Power Automate to handle this. Here’s how: Add the Create CSV Table  action. Choose your parsed JSON output as the input for this action. If you want to customize the columns, select Custom  under "Columns" and specify the fields you want in your CSV (like Order Date, Total Amount, etc.). This action will generate a perfectly formatted CSV file with all your data. Now in the screenshot you can see some Expressions. Reminder, while you will bring over some raw data from Power Apps you can still fix it up. Order Date I updated to make a nicer looking format and Total Amount I set to look like currency. Once again, all of the gory details are covered in the video. Sending Your CSV File via Email With your CSV file ready to go, you can do just about anything with it. In this example, we’re going to email the file as an attachment. Step 4: Sending the CSV as an Attachment Add the Send an Email (V2)  action to your flow. Then, use the following settings: To:  Your desired recipient (or just yourself to test it out!). Subject:  Something like, “Here’s your CSV export!” Body:  You can keep this simple for now, like “Check out the attached CSV file.” Attachment Name:  Export.csv (or whatever you want to call it). Attachment Content:  Use the output from the Create CSV Table  action here. Hit "Save," test it out, and if all goes well, you’ll receive an email with your brand-new CSV file attached. Bonus: Embedding Data as HTML Table (Optional) If you want to get even fancier, instead of attaching the CSV file, you can embed the data directly in your email as an HTML table. To do this: Add the Create HTML Table  action (instead of CSV). Use the same parsed JSON as the input. In your Send an Email  action, insert the HTML table output into the body of the email. Now, instead of a file attachment, your recipients will see a nicely formatted table right in their inbox! 📬 Wrap Up And that’s it! 🎉 You've just learned how to export data to CSV from Power Apps  using Power Automate. With this knowledge, you can take your data anywhere it needs to go—whether that’s an inbox, cloud storage, or even SharePoint. Exporting CSVs from Power Apps is a super practical feature, especially if you're working with large datasets or need to automate data sharing across different teams. So go ahead, give it a try, and make your life a whole lot easier! If you need help with this or any apps or flows, just click the Contact button and we are happy to help. We have services that range from 30-minute screen shares to full scale project development.

Are you tired of being stuck with the limitations of Gallery.Selected in your apps? Do you like having control of your app? Tired of confusing sequence for you users? Then take back control by switching to variables instead of Gallery.Selected. In this guide, we’ll dive into how to shift from using Gallery.Selected to a variable-based approach for better control, smoother navigation, and an overall improved user experience in Power Apps. We’ll go step-by-step on how you can introduce a single variable to manage record selections, handle new records more intuitively, and add more customization to your app—all while making your code cleaner and more efficient. And if you are more into seeing is believing then check out my 12-minute YouTube video Don't use PowerApps Gallery Selected Item Why Ditch Gallery.Selected? Using Gallery.Selected feels like a no-brainer when you first start building with Power Apps. It’s straightforward and provides an easy way to reference the record that a user clicks on. But… it’s not without its limitations: Lack of control: Once a user selects a record, Power Apps doesn’t let you control the next steps as much as you might like. This can lead to unintended highlights and inconsistencies, especially when users create or cancel new records. Inconsistent behavior: When a new record is created, the gallery often still highlights the previously selected item. Awkward, right? Limitations in multi-screen apps: Using Gallery.Selected across screens becomes tricky and isn’t as intuitive for users or developers. These limitations make a compelling case for switching to a variable-based approach, where we can leverage context and global variables to create a more reliable, user-friendly experience. Step 1: Setting Up Your Variable First things first, let’s create a variable to replace Gallery.Selected. You’ll use this variable to store the record information whenever a user clicks on an item in the gallery. Go to the gallery’s OnSelect property and add the following line of code to create a new variable (we’ll call it varRecord for simplicity): Set(varRecord, ThisItem) Now, instead of relying on Gallery.Selected, set your form’s Item property to varRecord. This will allow the form to reflect the selected record without directly depending on the gallery's selection. Step 2: Updating the Visual Cues Let’s add a few visual tweaks to make the selection experience smoother and more intuitive for users. This part is all about using varRecord to highlight the selected record, without those pesky issues tied to Gallery.Selected. Go to your gallery’s TemplateFill property and replace any reference to ThisItem.IsSelected with a condition that highlights based on varRecord . Here’s a quick example using the ID of each record: If(ThisItem.ID = VARrecord.ID, Color.LightBlue, Color.Transparent) Update any other properties that rely on ThisItem.IsSelected, like font weight or colors, using varRecord instead. Remember in the example above ID is the primary key column from the SharePoint list. If you are using another data source then you might not have ID as a column. Dataverse, for example, uses a unique identifier column that is named similar to the table name. The key is you need to find the primary column. Step 3: Customizing the New and Cancel Buttons Now that we’ve removed Gallery.Selected from the picture, let’s get our new and cancel record actions working flawlessly. For New Records: When a user clicks the “New” button, update varRecord to a blank value. This way, your gallery won’t highlight a record while the new form is open. Set(varRecord, Blank());NewForm(Form1) You may also want to repeat this step on the Cancel button. Or other places in your app you wish to clear the selected item. This approach ensures that your gallery and forms remain synchronized with each other, providing users with a seamless experience. Step 4: Setting Default Records (Optional) Want your app to open with a specific record highlighted? You can set varRecord to a default record (like “Greg” or “Chewy”) when the app starts. This is perfect if you want a particular item to show up as the default view when users first open the app. Steps: In your app’s OnStart property, add: Set(varRecord , LookUp(YourDataSource, ID = 1)) // Replace ID = 1 with your desired default Now, your app opens with the specific record highlighted automatically. No more blank first screens! In the video, you will see additional functionality, like adding a custom label that appears when the variable is blank and the form isn't in new mode like shown below. Now that you have complete control of when something is or isn't "selected" you can build whatever custom experience you would like. Benefits of Using a Variable Switching to a variable-based approach isn’t just a workaround—it’s an upgrade! Here are a few benefits: Better control : Gain more control over your gallery’s behavior, ensuring that records are only highlighted when and where you want them. More intuitive navigation : New and canceled records are handled seamlessly, without confusing the user with leftover highlights. Cleaner code : Using a single variable simplifies the app’s logic, making your code easier to read and maintain. Final Thoughts So there you have it! Ditching Gallery.Selected and embracing variables can give you and your users a smoother, more reliable experience in PowerApps. And, of course, it’ll make your app code cleaner, giving you less to troubleshoot when things go sideways. If you’re looking for even more PowerApps tips and tricks, we’re constantly adding new tutorials and updates. And if you’re curious about more ways to enhance your PowerApps skills, check out our training sessions. We offer everything from 30 minutes of mentoring to 30 years of project building, just hit the contact button and let us know what you need.

Seriously, does anyone enjoy getting a document, printing it out, signing it with a pen, scanning, and then sending it back to the requestor? Anyone??? I didn't think so. Thankfully the ability to esign documents is pretty common these days and accepted in most scenarios.  So today let's look at an end to end scenario using Power Apps, Power Automate, and docusign. And don't worry, while this is a getting started scenario we are going to do way more than hello world. We are going to:  - Build a Power Apps app that creates a PDF dynamically from our data - Add Signature blocks to the PDF with some HTML fun - Send the HTML to Power Automate to generate the PDF - Then use docusign actions to create an envelope and send it for signature - Once the document is signed have another flow upload it to SharePoint Now the blog post isn't going to be the 100 pages long it needs to be to teach you all of this. Below we have some more details but if you want to learn how to build all of this then you will need to check out my YouTube video:  Docusign for Power Apps and Power Automate   Power Apps to filter your data and create HTML While giving you a PDF and saying here look Mom we got it signed would have been easy, that isn't real. The whole magic of Power Apps is you can build what you want.  You could build your app to filter out invoices, generate a SOW, PO, or a contract for signature, or maybe to send internal HR documents that need a signature. By using the App you can build a nice interface to generate the unique content you need to send for signature. In the video we show filtering employee data but it doesn't matter, all that matters is you get well formed HTML with signature blocks hidden in it.  Power Automate to create a PDF The process of creating the PDF is the same as always with Power Automate. Create an HTML file in OneDrive for Business, convert that to PDF with the built in action, and then save the new PDF file. The good news is you don't have to change any of that when using docusign. When you generate the HTML in Power Apps you add HTML tags like below: Name: \\n1\\\\ Date: \\d1\\\\ Signature: \\s1\\\\ These tags will be replaced with docusign parts in the later actions.  docusign Actions In docusign now you are going to use a lot of actions. To make the process as flexible as possible they have every step in its own action. So you will need to create an envelope, add recipients, add tabs, and finally send the envelope.  No one step is hard, you just need to work through them logically and make sure you get everything you want. For example, in my HTML above I showed 3 blocks I wanted: Name, Date, and Signature. So I need to add three tabs for a recipient on an envelope. I am sure yours will be different.  Saving the Signed Document Back to SharePoint Alright, they have signed your PDF now you probably want to capture that file. In my case I wanted to put it in SharePoint. Turns out that is a pretty simple flow since there is a Power Automate cloud flow trigger for When an envelope status changes. Then you just get the document and save it to SharePoint. Boom! Practical Applications Think about HR departments needing approvals for hiring, project managers needing sign-offs for deliverables, or finance teams requiring authorization on budget documents. This kind of automated approval workflow can drastically reduce administrative load, eliminate bottlenecks, and keep projects moving forward smoothly. For example, in the scenario from the video, the system was used to collect managerial sign-off on employee lists filtered by department. The Power App allows users to dynamically adjust which data they want approved, and the entire process—from document creation to manager signature—is completed in a fully digital space, with every step tracked automatically. Closing Thoughts The combination of Power Apps, Power Automate, and DocuSign provides a powerful toolkit for businesses looking to streamline approval workflows. Not only does it save time, but it also provides the reliability and traceability that manual processes often lack. By reducing the need for human touchpoints, it minimizes the chances for errors and keeps everything moving smoothly—something every organization can benefit from. If you're interested in setting up something similar for your team, consider starting with a simple process that you can automate end-to-end. With tools like these, small changes can lead to big improvements in productivity and employee satisfaction. And of course, if you need help with this or anything Power related hit the Contact Us button. We have options from a 30 minute call to help you get unstuck to a 30-month project to help you automate EVERYTHING. Just let us know how we can help.

If you've ever felt limited by the default design options in Power Apps, you’re not alone. While the platform makes building functional apps easy, achieving truly stunning UI designs often requires creative use of advanced tools. Enter the HTML Text control . This often-overlooked feature unlocks a world of possibilities for styling and design, letting you create apps that are not just functional but visually engaging. In this post, we’ll explore three powerful HTML Text control tricks that can elevate your app designs: Glassmorphism , Dynamic Badges , and Gradient Backgrounds . Each of these techniques is easy to implement and delivers immediate visual impact, whether you’re designing an internal tool or a customer-facing app. Let’s dive in! If you want to see these concepts in action, check out our YouTube video on Use HTML Gradients and Styling to improve your Power Apps UI . Always a fun time, and of course if you need help with this or any Power Apps concept hit the Contact Us button, we are always happy to help. Glassmorphism: A Sleek, Modern Look What is Glassmorphism?  Glassmorphism is a design trend that creates a frosted-glass effect. You’ve likely seen it in modern user interfaces—semi-transparent backgrounds with a subtle blur and glow, as seen in the Severe Weather Alerts example below. Why Use It? Creates focus while maintaining context by blurring the content behind the element. Adds a polished, professional touch to your app. Makes overlays, modals, or navigation menus more engaging. How to Implement It in Power Apps   To achieve this effect, you’ll use the HTML Text control with inline CSS styling in the HTMLText property. Here’s the code ( Note:  make sure you begin and end with double quotes): "" Key Elements of the Code: background: rgba(7, 42, 200, 0.6 ): Sets the semi-transparency of the background. backdrop-filter: blur( 4px ): Applies the frosted blur effect. border-radius: 10px: Rounds the corners for a smooth, modern look. width:" & Self.Width-50 & "px; height: " & Self.Height-51 & "px:  sets the size of the to match the HTML Text control, adjusting for margins and ensuring the height is 1 pixel less to prevent a scrollbar. Pro Tip:  Use variables in PowerFX to dynamically adjust dimensions or colors based on user interactions or app state. Real-World Applications: Highlight key information with a frosted overlay. Create stylish modals or popups for alerts and confirmations. Design navigation menus that stand out without overwhelming the content. Power Apps Extreme Makeover is a live one day class that teaches all things Pretty Power Apps. Check it out here . Dynamic Badges: Highlight What Matters What Are Dynamic Badges?  Badges are small, attention-grabbing labels often used to display statuses, notifications, or other critical updates. They’re a simple but effective way to improve the usability of your app. Normally, badges with rounded edges are created using a container with a label inside. But it’s difficult to dynamically size such a badge if the label text is dynamic. Enter HTML Text. Using the method below, an HTML tag is used to create perfectly scaled dynamic badges using a single HTML Text control, reducing control count in your app and ensuring pixel-perfect scaling of your badge How to Implement It in Power Apps Here’s how you can create badges using the HTML Text control. Place the following code in the HTMLText property: "Severe Thunderstorm Warning Flood Watch" Key Elements of the Code: background-color: Defines the badge’s color, which can be dynamic based on data. padding and border-radius: Create a pill-shaped badge for a modern look. font-size: Ensures the text is legible even on smaller screens. Real-World Applications: Display task statuses like “Pending,” “In Progress,” or “Completed.” Highlight new notifications or updates. Use color-coded badges to indicate priority levels. If you enjoy learning from reading our blog posts, you will LOVE learning in on Training classes. We have Power Apps training available both on-demand and live. Classes for Power Apps, Power Automate, Power Pages, Power BI, and Copilot AI are all available. Gradient Backgrounds: Add Depth and Style What Are Gradient Backgrounds?  Gradients are smooth color transitions that can make your app visually appealing and professional. Whether used as section dividers or background elements, gradients add a touch of sophistication. Why Use Them? Breaks up monotony in the app design. Helps visually differentiate sections. Makes your app look modern and polished. How to Implement It in Power Apps To create a gradient background, use the HTML Text control with a linear-gradient style: " " Key Elements of the Code: linear-gradient(180deg, rgba(2,7,93,1) 0%, rgba(95,98,141,1) 100%): Creates a top-to-bottom gradient with two colors. width:" & Self.Width & "px; height: " & Self.Height-1 & "px: Fills the the HTML Text control, less the very bottom pixel when is necessary due to the odd behavior of the scrollbar showing up if the element exactly matches the height of the HTML Text control. Pro Tip:  Because this strategy leaves a white 1-pixel line at the bottom of the HTML Text control, set the Fill property of the HTML Text control to match the color at the bottom of the gradient (in the example, RGBA(95,98,141,1)). This will ensure a perfect background! Real-World Applications: Use gradients for section headers or banners. Highlight important data visualization areas. Add visual depth to dashboards and forms. Conclusion The HTML Text control is a powerful tool for transforming the look and feel of your Power Apps. By mastering techniques like Glassmorphism , Dynamic Badges , and Gradient Backgrounds , you can create apps that are not only functional but also visually stunning. These design tricks improve user experience, make your apps more engaging, and help you stand out as a Power Apps developer. Next Steps: Try these techniques in your own apps and see the difference they make. Explore more HTML and CSS tricks to expand your design capabilities. Watch the full video tutorial for a step-by-step guide to implementing these effects. Hit the Contact Us button to get support for this or any other Power Platform challenge you might be having.

Dataverse lookup columns are essential for managing relationships between tables in Power Apps. Whether you're building a Canvas App or integrating with Power Automate, understanding how lookups work can help you create more efficient and scalable applications. This post will walk you through everything you need to know about using lookup columns in Dataverse. If you're more of a visual learner, you can check out everything covered here (and more) in the YouTube video: Deep Dive in Using Dataverse Lookup Columns What Are Dataverse Lookup Columns? A lookup column in Dataverse creates a relationship between two tables. Instead of storing plain text or numbers, it stores a reference to a record in another table. This is useful when you need to maintain data integrity and avoid duplication. For example, in an Employees table, you might want to link each employee to a Region . Instead of storing region names as plain text, you can create a lookup column that connects to a Regions table. This ensures consistency and allows you to easily pull in related information such as a region code, manager, or goal. Tip: When creating the table, you'll look up against (like Regions in this example), take extra care when choosing your Primary Column . This text column will be the default in lookups and is often the only column you can display. Creating a Lookup Column in Dataverse To set up a lookup column: Navigate to Tables in Dataverse and open the table where you want to add the lookup. For our example, this is the Employees table. Click Add Column and choose Lookup as the data type. Select the related table (the Regions table in this example). Save the column and verify that the relationship has been created. Using Lookup Columns in a Canvas App Once you've created the lookup, you can use it inside a Power Apps Canvas App. Here are a few common scenarios: 1. Displaying Lookup Data in a Gallery If you add a Gallery control to show employees, you can display related region names using: ThisItem.WorkRegion.RegionName ThisItem.WorkRegion is the full record of the item you're looking up. This means that instead of just .RegionName , you could reference .RegionManager , .Goal , or any other column from the record. This is called a polymorphic lookup and is a great feature of Dataverse lookup columns. 2. Filtering by Lookup Column To filter employees by a specific region: Filter(Employees, WorkRegion.RegionCode = "EU") Since the lookup column stores an entire record, you must specify the field you want to filter on (for example, RegionCode ). 3. Saving Data with a Form If you use a Form Control , the lookup column will automatically show a dropdown with related records, making it easy to select values. Nothing special to do here. 4. Patching a Lookup Field If you prefer using Patch instead of forms, you need to provide a record when updating a lookup column: Patch(Employees, Defaults(Employees), { FirstName: "John", WorkRegion: LookUp(Regions, RegionName = "North America") }) In that example, we used RegionName as the text to look up. Often, you'll want to use something you know will always be unique (like the GUID primary ID column). It doesn't matter, as long as LookUp returns a matching record. Using Lookup Columns in Power Automate When working with lookup columns in Power Automate , you might need to use OData queries to filter or retrieve data. The lookup column’s system name often follows this format: _cr662workregion_value eq 'GUID' For example, to filter employees by region in a List Rows action: _cr662workregion_value eq '2a6ddb65-cfeb-ef11-be21-6045bdedb9f2' In the video, we went into detail about how to find these exact values for your tables. If you're struggling, check out the video for a walkthrough. You can also expand related data using the `$expand` parameter. Relationship Behaviors and Cascading Actions Dataverse lets you define how relationships behave when a parent record is deleted. The most common options include: Referential: Deleting a parent does not affect child records. Restrict Delete: Prevents deletion if related child records exist. Cascade Delete: Deleting a parent removes all related child records. Wrapping Up Dataverse lookup columns are a powerful tool for creating structured relationships between tables. Whether you're displaying data in Power Apps, filtering records, or integrating with Power Automate, understanding how lookups work will help you build more robust applications. If you have any questions or want to learn more, click the Contact button—we're happy to help! We have consulting and training options to assist you with this or any other challenges you might have.

When working with SharePoint data in Power Automate, filtering your dataset efficiently is key to building optimized workflows. One of the most powerful ways to filter SharePoint data is by using oData filter queries  in the Get Items  action. This post will walk you through different examples of filtering various column types  and using logical operators  to refine your results. If you want to see all of the concepts from this blog post in action then check out the full length video where we go hand on with these and other examples of oData filtering. You can find the YouTube step-by-step video here: Filter SharePoint Data in Power Automate with oData Understanding oData Filter Queries in Power Automate oData (Open Data Protocol) is a standard query language that enables filtering and querying data efficiently from multiple data sources, including SharePoint, Dataverse, and SQL Server. When used in Power Automate, it allows you to retrieve specific records without pulling unnecessary data, improving performance and efficiency. For the examples in this post, we will be using the Power Automate Cloud Flow action "Get Items"  to filter SharePoint list data. However, it’s important to note that oData queries are widely applicable across various platforms, including Microsoft Dataverse, SQL Server, and even third-party services that support the oData standard. Learning how to construct and apply these queries will benefit you in multiple automation and data retrieval scenarios. An example of the Get Items action with an oData Filter Query for the Created by field in SharePoint Filtering Different SharePoint Column Types Each SharePoint column type has its unique characteristics and filtering them requires different approaches. Below are practical examples of how to filter single-line text, choice, lookup, number, and date columns  using oData. 1️⃣ Filtering a Single Line Text Column For a text-based column , you use the eq (equals) operator. The column name is case-sensitive and must match exactly as it appears in SharePoint. Example: Title eq 'Project X' This retrieves all SharePoint list items where the Title column is Project X . 2️⃣ Filtering a Choice Column Choice columns require the same syntax as text columns. Ensure you use single quotes around the value. Example: Department eq 'Sales' This filters all items where the Department  choice column is set to "Sales." 3️⃣ Filtering a Multi-Choice Column Multi-choice columns can contain multiple values, so filtering them requires an exact match. Example: Skills eq 'Power BI' This filters records where the Skills  column contains exactly "Power BI." For filtering multiple selections: Skills eq 'Power BI' or Skills eq 'Excel' This retrieves items where Skills  include either Power BI  or Excel. Pro Tip:  If you're unsure of a column’s internal name, check the List Settings  in SharePoint or inspect the raw JSON output from a Get Items  action. 4️⃣ Filtering a Lookup Column Lookup columns reference values from another list. The default way to filter is using the ID  of the lookup record. Example: DeptLookUp eq 3 This retrieves all records where the Department lookup field  has an ID of 3. If you prefer filtering by the title  of the lookup field: DeptLookUp/Title eq 'Marketing' This pulls items where the related department’s Title  is "Marketing." 5️⃣ Filtering by Number Values Number fields support operators such as eq, gt, lt, and le. Example: Age gt 30 This retrieves all items where the Age  column is greater than 30. To filter within a range: Age gt 30 and Age lt 50 This gets records where the age is between 31 and 49. 6️⃣ Filtering by Date Values Dates in SharePoint require a special format: YYYY-MM-DDThh:mm:ss. Example: HireDate ge '2020-01-01T00:00:00' This retrieves employees hired on or after January 1, 2020. To find records within a year: HireDate ge '2022-01-01T00:00:00' and HireDate le '2022-12-31T23:59:59' This filters records where HireDate  falls within 2022. 7️⃣ Filtering by Created By (Author) Field The "Created By" field in SharePoint is internally referred to as Author. To filter based on this field, you need to use /Email or /Title depending on whether you want to match an email or a display name. Example: Author/Email eq 'user@example.com' This retrieves all records created by user@example.com . If filtering by display name: Author/Title eq 'John Doe' This pulls items where the Created By  field matches "John Doe." Be mindful that display names are not always unique. Using Logical Operators: and, or, Parentheses oData allows for complex filtering by combining multiple conditions using and, or, and parentheses. Make sure you use them all lower case. Combining Filters with AND Department eq 'HR' and Age gt 25 This retrieves employees from the HR department who are older than 25. Combining Filters with OR Skills eq 'Power Automate' or Skills eq 'SharePoint' This retrieves records where employees have either Power Automate  or SharePoint  skills. Grouping Filters with Parentheses (Department eq 'IT' or Department eq 'Finance') and Age lt 40 This retrieves all employees from IT or Finance  departments who are younger than 40. Conclusion oData filtering in Power Automate is a powerful way to query SharePoint data efficiently. Understanding how different column types work and applying the correct operators ensures that your workflows run faster and return the most relevant data. If you need help with this, remember we have support services where someone will hop on a screenshare with you for as little as 30 minutes to help. Just hist the Contact button and let us know how we can help.

Covering Text Inputs, Number Inputs, Text Labels, and Buttons Modern Controls are all of the rage but as long-time builders we often find ourselves asking what is new and what is different. Below I have offered some overall thoughts and documented three of the most common controls in detail. Hopefully, this helps you quickly bridge the differences between the two. And yes, Input Controls have a lot of notes. They are drastically different, whereas labels and buttons are mostly visually different. If you want a more hands on look at these differences then be sure to check out my Youtube video Modern vs Classic Controls in Power Apps - Buttons, Text Inputs, and Text Labels Finally, if you are having a hard time with the different properties for these controls, you can download this guide with all of the properties mapped out using the fancy link below. It includes each Property name and description, what control it is applicable for, and if it was renamed from Classic to Modern what the new or old name was. Lots of little details to make your life easier. Example for the Inputs: Download the guide⬇️ General Notes of Differences for Modern and Classic Controls in Power Apps Below is a breakdown of just things to know going into using Modern Controls with Power Apps. Hopefully these little notes help you pull out your hair a bit less when you trip over things like OnSelect being gone for most controls. Styling : Modern Controls follow Fluent UI guidelines for styling, offering consistent themes and polished looks. At the expense of not being able to manually set a lot of the visual properties yourself. For example, properties like DisabledFill, HoverColor, and PressedBorderColor that were available in Classic Controls are currently not present in Modern Controls. This means you'll lose some of the fine-grained control over the appearance of your app in different interaction states. For example: I often would set the visual properties of disabled mode in a control to very specific colors to achieve a desired effect for one control in classic controls, this level of customization is no longer available. Font Sizing : Modern uses pixels while Classic uses points, often leading to inconsistent font sizes across controls. So basically, when you start adding Modern Controls be prepared for everything to be smaller, you will need to rethink what are your default font sizes and such. Themes : The Modern Controls use the new theme engine. It is kind of configurable but will add to your confusion in the short term. To view/configure what you can with themes look on the Left Rail and click … to find Themes. Then to manipulate per control click on the control and at the bottom of the Properties panel on the right you will see similar to below. Accessibility : Classic Controls include more traditional accessibility features such as Live and Role, while Modern Controls are progressively incorporating these features. One of the goals of Modern Controls is to be more accessible. OnSelect isn't as common : With Classic Controls just about every control had an OnSelect property, making them all "clickable". That is not the case with Modern Controls, if you want something to be clickable you are most likely going to need to use a Button, Icon, or Image control.  Reset property is gone : If you got used to using a variable to trigger mass resets, sorry that isn't possible. Back to Reset(ControlName)  being the only option. Avoid mixing and matching : Modern Controls and Classic Controls are so different, especially visually, it is basically impossible to combine them in the same app and have it look nice. So, commit to one or the other. Text and Number Input Control Differences Quick note. This one is a bit odd because the Classic Text Input has been replaced by two controls. Text Input and Number Input are separate controls that are similar but have nuance difference. Most of which is covered below.  Trigger Behavior : Classic uses DelayOutput; Modern replaces this with TriggerOutput offering options like FocusOut, Delayed, and Keypress. While this is a nice change, you will need to think about how your OnChange is triggered, each of those 3 options have their own quirks to meet specific scenarios and none exactly line up with how it worked in Classic Controls. Clear Button and Spell Check : Classic included a built-in clear button and the ability to enable Spell Check. Disabled vs. Enabled : With Classic Controls a Text Input in view mode looked exactly like a label, which made it easy to reuse the control for display-only purposes. Now a view mode Text Input looks exactly like an edit mode Text Input, which isn’t ideal and is confusing to users. You can't easily reuse the same control for editable and read-only scenarios without causing confusion. Which would change how I designed the look of a lot of apps over the year.  Number Input is Separate : In Classic, you often used a Text Input with formatting rules to handle numbers. In Modern, there's a dedicated Number Input control with its own properties like Min, Max, Step, and Precision. This makes numeric input more flexible, but also means managing a new set of behaviors and edge cases. Number Input : The control now has an up and down increment arrow you can use to adjust the value in the control. It is kind of hard to see. If you want to get rid of it set the Step property to 0. Not very obvious. Value vs. Text : Number Input uses a Value output property instead of Text. This can be helpful for calculations but may require some refactoring if you're used to string-based logic. This means to get the number out of a Modern Number Input Control you would use NumberInput1.Value where as with a Text Input you would use TextInput1.Text. Overall : Lots of change with Inputs plus the fact that number inputs are the same but different will probably cause you a bit of confusion for a while. But don’t worry, once it clicks, it will all make sense. Text Label Control Differences OnSelect : Worth repeating, it is gone, as that one really frustrated me. If you want to simulate an interactive label, one workaround is to overlay a transparent button on top of the label and use its OnSelect instead. Visual Everything:  The alignment, the size, the padding, everything is different. It is fine, just be ready to reconsider the look and feel as you add these new labels. If you are new to Power Apps then not a big deal, you will never know the difference.  Below they are both using default size and both are against the top of the screen. Font size and vertical align are easy to see differences, but there are plenty more. Overall : Functionally is very much the same, just visually different. Button Control Differences Icons : Modern Controls allow inline icons with Icon, IconRotation, IconStyle, and Layout; Classic does not. Hover and Pressed States : Classic includes HoverFill, PressedFill, DisabledFill, and more; these are currently missing in Modern. Overall : Good news, a button is basically still a button, just with different sizing and style.

Ever felt the frustration of trying to convert various image types into a PDF without shelling out for a "Premium" action in Power Automate? You're not alone! But guess what? We've cracked the code. Dive into our innovative technique that leverages an HtmlText control to generate HTML, enabling Power Automate to seamlessly create PDF documents. And the best part? This method effortlessly incorporates images from a SharePoint list image column. Ready to revolutionize your workflow? Let's get started! SharePoint list with image columns First, you’ll need a SharePoint list with some image columns. We can insert some images into the list, either JPEG or PNG. Then we connect this list as a data source for our app. Screen with HtmlText and Image controls Next create a blank app with Power Apps. Add some Image controls to the screen (corresponding with the number of images you want to use) and an HtmlText control. We’re going to add some code (that refers to the image controls) that runs OnVisible  property of the screen. The image controls are tied to the SharePoint list images, either through a variable or a LookUp  based on the ID or another “key” column (our example is the ParentID column). How we harness JSON and extract base64 The first thing we do is get the JSON string of the image via the JSON  function, then we determine the image format (PNG or JPEG), then we set a formatting variable for string manipulation to extract the base64 string from the JSON string, finally we assign the base64 string to a variable that we can use in our HTML. That’s the key this technique! Screen OnVisible code Let’s break down the code in the screen OnVisible , line-by-line. Then we’ll put it all together once we’ve explained it. In this section, our examples show the code as though we’re pulling two images into the HtmlText control, but the steps below just show you how to do it for a single image. (You can repeat this technique for multiple images in your HtmlText control.) First, we use a With  function pointing towards an Image  control. You could simply insert the JSON  formula into your variable calculation for varImage1, but you’d have to do it 2x. The With  function is more performant, as it’s similar to defining a context variable. With({jsonImage1: JSON(Image1.Image, JSONFormat.IncludeBinaryData)}, Next we use a series of Context variables . Why? Simply because we don’t have to reset them (since they don’t reside in memory beyond the active screen). Since the calculation of subsequent variables depends on the previous variable calculations, we need to use the UpdateContext formula several times, in a sequence. Our first Context variable is for the image format . It looks for “.png” and “.jp” in the image text string within the JSON data. How can you view this text? Just insert a Text  or Label  control onto your screen, and make your Image1.Image the Text  property, and you can see the complete text string. Within that text string, you’ll be able to see the image file suffix, but you must search for it. So, in the formula, we use the Find  formula to look for the image format. The Find formula will either return blank or an integer, so we use a greater than operator to see if the value is greater than 0 to determine what type of image it is (PNG, JPEG or “unknown”). Then we use this value in the next context variable. Additionally, this variable also goes into the HtmlText control in the HTML text string. This is our “Format” variable: UpdateContext({varImage1Format: If(Find(".png", Step1Image.Image) > 0,"png", If(Find(".jp", Step1Image.Image) > 0,"jpeg","unknown"))}) Our next variable helps us modify our text string to extract the base64. PNG files have base64 code beginning with “iVBOR” whereas JPEG base64 code begins with “/9j/”, so we need to feed different values into our Mid  function when we’re extracting the base64 code from the JSON string of the image control. We could have used a single If  function, but we wanted to have a way to confirm that the item is a JPEG. We use this variable as input into our next variable that extracts base64. This is our “String manipulation” variable. UpdateContext({varImage1Code: If(varImage1Format = "png", 24, If(varImage1Format = "jpeg", 25, 24))}), In our next variable, we slice off everything we don’t need to create the base64 code that our HtmlText control can recognize as an image. This is our “base64” variable. UpdateContext({varImage1: Mid(jsonImage1, varImage1Code, Max(Len(jsonImage1) - varImage1Code, 0))}) That’s it for the OnVisible coding, here’s the complete block of code (including some remarks): With({jsonImage1: JSON(Image1.Image, JSONFormat.IncludeBinaryData)},             //Image1Format looks for .png or .jp(eg) in the text string to determine the format for the HTML                 UpdateContext({varImage1Format: If(Find(".png", Step1Image .Image) > 0,"png", If(Find(".jp", Step1Image .Image) > 0,"jpeg","unknown"))}),             //Image1Code bases the position for the Mid function to check: 24 for png and 25 for jpeg             UpdateContext({varImage1Code: If(varImage1Format = "png", 24, If(varImage1Format = "jpeg", 25, 24))}),             UpdateContext({varImage1: Mid(jsonImage1, varImage1Code, Max(Len(jsonImage1) - varImage1Code, 0))}) Code for the HtmlText control We inserted an HtmlText control on our screen. Since we’re just using the text from this control in our Power Automate flow, it’s not necessary to make it visible, but we did, just so we could ensure that the images render properly before initiating the flow to turn it into a PDF. To make the image format dynamic, we used our varImage1Format  variable. The base64 text string from the image is in varImage1 . This is how we added the code inside of an HtmlText control to display the image: "" In our example above, the image on the left with the cat is a JPEG and the image on the right with the tank is a PNG. Both render properly in the HtmlText control. (Your HTML can include text, tables, and dynamic content other than your images, but this post focuses on the image piece.) Now you have HTML text that you can submit to Power Automate to build your PDF. Let’s look at how to build your PDF flow. Create the PDF flow When you build the flow, if you’re not already in a solution, you should initialize the flow from Power Apps to link it to the app. Else, if you create it straight from Power Automate, you’ll need to add both app and flow into a solution so that you can add the flow to your app. Once you’ve created the flow and it’s tied to your app, you can then enter the flow from Power Automate to continue editing. Let’s go through the flow. The trigger is “When Power Apps calls a flow (V2)”. Your input must include the text input including the HtmlText from your HtmlText control. Then use a OneDrive (for business) “Create file” action. This action will create a temporary HTML file in OneDrive that you can use for the next action. For the “File Name” you can use something like test.HTML. For the “File Content” use the dynamic content for the HTML text input from Power Apps. Next, we use a OneDrive (for business) “Convert file” action. The “File” input is the Id dynamic output from the “Create file” action. Ensure you select PDF  (default) as the “Target type”. This step does not create the file; it merely reformats the HTML into PDF. You must save the code next. To save the PDF code, use a “Create file” SharePoint action. This action adds your new PDF to a document library so you can refer to it from your app. You can use dynamic content for the File Name or simply create a name with a suffix of “.pdf”. If you don’t have a unique file name, each subsequent time your flow runs it will fail, because the SharePoint “Create file” action must patch a unique File Name . In the formula below, using the concat  function, utcNow()  provides a unique prefix, and then we add ‘.pdf’ to it to correctly identify the file: concat(utcNow(),’.pdf’) Optionally, you can include a “Respond to a Power App or flow” step that includes a link to your new document. You can title a text output as “Link” and add a formula using a concat  function, similar to this: concat(‘[your SharePoint document library]’, outputs(‘Create_file’)?[‘body/Path]) This formula adds your document library “https” address such as: https://shanescows.sharepoint.com/sites/DoeHillDrive                 …to the dynamic content Path from your “Create file” action. You'll simply replace the part of the formula ([your SharePoint document library]) with your own document library. This PdfLink value will be output to Power Apps during the flow run. You can save (and publish if it’s in a solution) and close your flow. Finish the app Return to your app, select the (…) button from the left side rail, and then Power Automate. Make sure that the flow is in your app. Note the schema name under the title, because that’s what you’ll use to call the flow:   Next, we add two button controls to our screen, one for initiating the flow, and the other for using the link that returns from the flow. We’ll name one PDF and the other Link. Because we used the Respond to a Power App or flow  action in Power Automate, we can harvest that link data by adding a Set  function to the button calling the flow in the OnSelect  property of the PDF  button. Here’s an example: Set( varPdfLink, CreatePDFfromHtmlText.Run (HtmlText1.HtmlText).pdflink); With the link saved to the global variable called varPdfLink , you can now use that with a Launch  function in Power Apps that opens the new PDF document in another browser tab. You can add this code to the OnSelect property of your Link  button. Launch(varPdfLink) If you run your app, you will be able to use any JPEG and PNG images in your PDF document. You can continue to add HTML code to your HtmlText control to add data to your PDF, but now you understand how to add different image types to the PDF. Here’s how ours looks: Please let us know what you think! For more on this topic, don't forget to check out Shane's video on creating a PDF: Create a PDF from SharePoint Data using Power Apps and Power Automate flow for free

Recently, a change in Microsoft Power Apps affected a common method for enabling file uploads. The attachment control, which users typically copied from a form into a standalone app, no longer functions correctly when used outside the form context. This disruption has affected many makers who relied on that approach since its emergence in 2019. If you've encountered this issue, you're not alone. Fortunately, there's a workaround that helps make it easier to keep file upload functionality in your app—without waiting for a product fix. Shane has documented this in his video: Power Apps Bug & Fix: Attachment Control. What Changed Previously, the process involved: Connecting your app to a SharePoint list. Inserting a Form  control connected to that list. Adding the Attachments  field to the form. Copying the Attachment  control from the form and pasting it elsewhere in your app. Now, when you try to copy and paste that control—even within the same form—it no longer functions properly. The paperclip icon that triggers the file picker disappears, and the control becomes unusable. The Workaround: Drag, Don’t Copy Here’s how to restore file upload functionality: Add a Form to your screen and connect it to a SharePoint list (any list with attachments enabled). Edit the fields in the form to include the Attachments  control. Instead of copying the control, click and drag the entire data card that contains the attachment control outside the form . You’ll see some formula errors. Clean those up by: Removing or correcting the Items property. Setting DisplayMode to Edit. Optionally adjusting styling (e.g., Color to Color.Black ). Once it works, delete the form. The dragged control will remain functional. Why This Works Dragging preserves internal bindings that are lost during copy-paste. This technique isn't documented, and Microsoft hasn't officially acknowledged it as supported behavior. However, it allows your app to continue supporting file uploads until an official fix is released. Known Bug Reference Microsoft has documented this issue as Bug 5096864 , noting that the control "is not designed to work outside of a form." This workaround sidesteps that limitation until the functionality is restored or officially restructured. Final Thoughts If you're building or maintaining apps that rely on file uploads, this drag-and-drop method  offers a workable path forward. We'll share this workaround with Microsoft to help drive resolution. In the meantime, you can keep your apps running smoothly using this approach. For a visual walkthrough, check out the linked video tutorial .

If you've ever felt a bit overwhelmed by the Combo Box control in Power Apps, you're definitely not alone. It's one of the most powerful (and sometimes puzzling) components out there. But don't worry, in this guide, we’re diving into the modern Combo Box, and by the end, you’ll have a solid grip on how to make it work for you. Now if you are more of a visual learner than a reader, there is a full-length video Deep Dive for the Modern Power Apps Combo Box . Me I prefer seeing that reading, so hopefully the video also helps you. Getting Started: Enabling the Modern Combo Box Before you can use the modern Combo Box, you need to turn on the feature in Power Apps: Go to Settings  > Updates  > Modern Controls and Themes  > Toggle ON Insert a Combo Box from Insert  > Input  > Combo Box Populating the Combo Box By default, the Combo Box comes with sample items (Item 1, 2, 3), but that's not what we want. Connect it to a real data source like a SharePoint list, Dataverse table, or SQL. In the video, a list called "Mega" with 10,000+ items is used. One key limitation: the Combo Box only loads the first 800 items . That might sound like a lot, but if your list is bigger, you’ll need to filter or search more effectively. Filtering Items To narrow down the results, you can use the Filter() function. For example: Filter(Mega, AnimalType = "Cow") This helps make large data sources manageable within the 800-item cap. Search Functionality Modern Combo Boxes only search the first 800 items. For a more robust, traditional search, use the Search() function like this: Search(Mega, Self.SearchText, "Title") This makes your Combo Box smarter, especially with large data sets, but keep in mind delegation warnings. Default Selected Items Setting default values can be tricky. The DefaultSelectedItems property expects either a record or a table. To default to a specific item: LookUp(Mega, Title = "Item Title 22") Or use a custom JSON record, but be careful it must be an exact Record match: {Title: "Item Title 22"} If you are struggling with setting the DefaultSelectedItems use this video Power Apps Combo Box DefaultSelectedItems . The video is old but the content has not changed. Multiple Selections Turn on Allow Multiple Selections  to enable checkboxes in the Combo Box. This makes it easy for users to select more than one value. To pull out selected data, use: Concat(ComboBox1.SelectedItems, Title, ", ") This gives you a nice, comma-separated string of all selected titles. Working with People Search Want to select users from Office 365? Add the Office365Users  connector, then set the Combo Box items like this: Office365Users.SearchUserV2({searchTerm: Self.SearchText}).value Use DisplayName for the field shown in the Combo Box, and pull email addresses using: Concat(ComboBox2.SelectedItems, Mail, ";") Bonus: Rounded Corners and Styling Finally, a small but delightful update, modern controls now support border radius ! That means rounded corners are just a click away. Style away to match your app’s vibe. Wrapping Up The modern Combo Box in Power Apps brings a lot of new features and a bit of a learning curve. But once you get the hang of filtering, searching, and managing selected items, it becomes a flexible and user-friendly control. Don’t forget to explore delegation limits and always test with your actual data. Got questions or need help? Hit us up with the Contact button and tell us how we can help.

If you're building custom forms in Power Apps and want a cleaner, more flexible input experience, you can take advantage of the  Modern Text Input control. It's designed to be simpler, more accessible, and more in line with current design standards. While there are some great features to try, there are some buggy tradeoffs that make us not quite ready to completely give up the Classic Text Input. This post breaks down what matters most—especially for developers skipping the Form control and building a custom form. We'll look at some of the properties that have changed, what the new ones do, and how to handle validation. All in less than 5 minutes. Classic vs. Modern Property Mapping Here's a quick table to highlight what's changed: Modern Property Classic Equivalent Notes Value Default Holds a default input value of "". No need to replace "Text input". Placeholder HintText Shows hint text when empty. Mode Mode SingleLine or MultiLine only (no Password--see Type). Type (None) New. Choose "Text", "Password", or "Search"--see Type below. TriggerOutput DelayOutput New. More flexible—see TriggerOutput below. Required (None) New. Marks the input as required. ValidationState (Manual styling) New. Set to "Error" to show a red border. Note: Values like Type and Align properties are set using text strings (e.g. "Password", "Center")—not Enum syntax like Align.Center . Type property This property gives the text input a specific role: "Text" – Default. Accepts any text. "Password" – Masks input with dots. Shows a selectable view input toggle. "Search" – Meant for search bars. Currently, there's no difference from a "Text" type. (However, it may show a search icon or clear button in the future.) If you're asking for login info or PINs, use Type = "Password". Otherwise, stick with "Text" or "Search". TriggerOutput property This one's important if you're doing logic as you type. It controls when OnChange  fires and when the control's Value updates: "FocusOut" – Default. Fires when the user leaves the field. "Delayed" – About 500ms after typing stops. "WhileTyping" – Updates as the user types, but throttled. "KeyPress" – Fires on every keystroke  (use with caution). Pro tip : Use "WhileTyping" if you're building responsive custom forms. It's smoother than "KeyPress" and doesn’t trigger on every character. If you're tabbing through inputs, use the "FocusOut" . Required and ValidationState These two make field validation easier: Required   = true – Tags the control as required (mostly informational unless you're using forms). ValidationState = "Error" – Turns the border red. You control this manually. Here’s a quick example you can include in OnChange or OnSelect of a control: If(IsBlank(TextInputName.Value) UpdateContext({varNameError: true}), UpdateContext({varNameError: false}) ) Then bind the property: ValidationState = If(varNameError, "Error", "None") Boom—built-in red border. Bonus Tip: Use the Number Input control for Numbers If you're asking for a number, don’t use a text input . The new Number Input control: Opens the right keyboard on mobile Has increment/decrement buttons (with a customizable Step) Enforces numeric input by default It’s mostly better all around. Why We're Not Ready to Give Up the Classic Text Input While the Modern Text Input is sleek and evolving quickly, it’s not quite feature-complete yet. Here are a few frustrations: There is no " Clear button " (or " Enable spell check ") option. The AcceptsFocus  property isn’t available, so using SetFocus() can get wonky, especially when paired wit h TriggerOutput  = "WhileTyping" . Customizing tab navigation isn't an option. The FontSize  property (Size in the Classic Text Input) is too small when you first insert the control, prompting you to adjust it. The OnSelect  pr operty is missing, so if you need to do something when a user taps the field, you’ll need a workaround. Until these gaps are closed, the Classic Text Input still earns its spot in certain custom form scenarios. Wrap-Up As with other Modern controls, the Modern Text Input shows true promise, but it isn't quite what we're expecting, yet. They're stylish and clean and have a growing range of options. They can enhance the look and feel of your app, but some things they still can't do. There's still a place in our toolbox for the Classic Text Input.

Ready to have your mind blown? That may be a little much, but we are pretty excited for this and think you will be as well. Let’s start with a quick look at how we used to add the Attachment control. Previously, adding the Attachment control involved multiple steps, such as adding a data source, inserting an Edit form, adding the Attachment field, and then manually copying the control outside the form to configure it. That worked for years, still does, and there’s nothing wrong with that approach. Maybe a little excessive on the steps, but hey, it works. But what if I told you there was an easier way to add the Attachment control (or any other control for that matter) in your Power Apps. Odds are if you’re reading this, you are at least somewhat interested ha. You can do this with any existing app or start with a blank app, it’s up to you.  For our example we will be using a blank app to keep things simple. From the Power Apps editor, click the Ellipses at the top and select Settings . On the Settings window, click Support . Make note of the Authoring version, it’s probably 3.25061.7 . We need to change that. Below Authoring version, click Edit . Then, under Authoring version, click the drop-down and select 3.25063.5 . (Your version may be different, but you just want to select the newest version.) Once selected, click Reload + apply version . Power Apps is then going to reload your app and reopen. It’s always a good idea to double-check that your changes were saved and your Authoring version was updated. So, take a moment to confirm your Authoring version now shows as 3.25063.5 or again the version you selected. It’s also important to note that, as a rule of thumb, we don’t recommend doing this in any other cases, as it can get people in trouble. BUT if you need the attachment control working again, you will need to update the Authoring version. And hey, Shane said it’s ok, so it must be alright 😊 Now that the version is updated, you can simply copy and paste the YAML code for the attachment control right into your app. If you’re thinking to yourself, What is YAML code? Let me assure you, it’s fine, you are not alone either 😊. We aren’t even going to get into it, just know that code is what allows you to paste these controls into your apps. Let’s check out how it works. So, from my text editor, you can see the YAML code and properties for the Attachment control. I’ve also included the YAML code below so you can copy and paste it into your app. - Attachment1: Control: Attachments Properties: BorderColor: =Color.Purple BorderThickness: =5 Fill: =RGBA(169,169,169,.5) Height: =268 MaxAttachments: =1 Size: =18 Width: =402 X: =60 Y: =111 All I have to do is copy the code , go into Power Apps, and paste it . Boom! You will see the attachment control is now there and configured with the properties specified in the code. Again, this will work with any of your controls. If you want to get the YAML code for a control, you can add it to your app, right-click on the control, and select View code. If you want to watch the video where Shane walks through these steps, check out the video below.   Whether you are new to Power Apps or an experienced builder, everyone runs into roadblocks. If it happens, just know we are here to help however we can. Just click here , send us a message, and we will be in touch soon.