Picture this: your field inspection team is out at a job site. They find a problem — a cracked pipe, a safety hazard, a damaged shipment — and they need to log it. The old process? Snap a photo on their phone, go back to the office, attach it to an email, wait for someone to enter it into a system manually. The new process? Open a Canvas App on their phone, fill out the inspection form, take a photo right inside the app, and submit it — all in one step.
That's the transformation you're going to build today. Power Apps gives you two controls that bring media collection directly into your forms: the Camera control, which lets users capture photos live using their device's camera, and the Add Picture control (sometimes called the Image control in attachment mode), which lets users upload existing photos or files from their device. Together, these controls turn a plain data entry form into a proper field tool. We'll also cover the Attachments control, which connects directly to SharePoint and lets users attach multiple files to a list item — the choice most business apps actually need.
By the end of this lesson, you'll understand how each control works, when to use which one, and how to wire them into a real form so that photos and files actually end up saved somewhere useful — not just sitting in a temporary variable.
What you'll learn:
Before diving in, you should be comfortable with:
Patch() function (used to save records)If you haven't worked with data sources and Patch yet, review the Canvas Apps 101 lessons on connecting data and saving form data before continuing. This lesson builds directly on that foundation.
Before touching any control, you need a mental model of how images move through Power Apps — because this is where most beginners get confused.
When a user takes a photo with the Camera control or selects a file with the Add Picture control, the image is temporarily held in memory as an image object. Think of it like a sticky note: the image exists and you can see it, but if you close the app or navigate away without doing something deliberate with it, it's gone. The data is stored as a base64-encoded string (a long text representation of the image's binary content) or as an image URI pointing to a temporary location on the device.
This is fundamentally different from how desktop software works, where you might just reference a file path. In Power Apps, the image lives in the app's memory until you explicitly save it somewhere — either to a SharePoint list, Dataverse, or another data source.
There are three main controls for handling images and files:
| Control | Best for | Saves as |
|---|---|---|
| Camera | Capturing a new photo live | Image object / base64 |
| Add Picture | Selecting an existing file from device | Image object / base64 |
| Attachments | Attaching multiple files to a SharePoint list item | File attached to list record |
Let's work through each one.
Open your Canvas App in Power Apps Studio. Navigate to the screen where your form lives. On the left panel, click Insert, then search for "Camera." Click on it to drop a Camera control onto your screen. You'll see it appear as a viewfinder rectangle — in the browser editor, it shows a placeholder, but on a real device, it activates the device's physical camera.
Resize the control so it's large enough to be practical. For a field form, something roughly square — say, 300 by 300 pixels — works well. Set these in the right-hand Properties panel or directly in the formula bar.
The Camera control is a streaming control by default. That means it continuously shows a live feed. The magic happens when a user taps it — that tap triggers the OnSelect property, and at the moment of that tap, the control's Photo property captures a snapshot of whatever the camera is currently showing.
Here's the key concept: CameraControl.Photo holds the most recently captured image. Every time the user taps the camera, this value updates. It does not accumulate a list of photos — it holds exactly one image at a time.
You need to save the captured image to a variable so you can reference it later when submitting the form. Set the OnSelect property of your Camera control to:
Set(varCapturedPhoto, Camera1.Photo)
Set() creates a global variable called varCapturedPhoto and stores the current photo in it. Now you can use this variable anywhere else in the app.
To give users visual confirmation that the photo was captured, add an Image control to your screen (Insert → Image). Set its Image property to:
varCapturedPhoto
Now when the user taps the camera, the preview Image control will update immediately to show the captured photo. This is important UX — users need to see what they captured.
Assume you have a SharePoint list called FieldInspections with columns: Title, Location, Notes, and InspectionPhoto (a column of type "Image" or — more practically — you'll store it as a hyperlink to a blob, but let's stay practical here).
Practical note: SharePoint doesn't have a native "store base64 image" column that works seamlessly with Power Apps camera output. The most reliable pattern is to save the image as an attachment to a SharePoint list item, which we'll cover in the Attachments section. For the Camera control specifically, the most common production approach is to use Power Automate to convert the base64 image to a file and store it in SharePoint or Azure Blob Storage. For this lesson, we'll show you how to pass the image to Patch for a Dataverse image column or as a preview — and explain the SharePoint attachment approach in the next sections.
For Dataverse (which has a native image column type), the Patch() call looks like this:
Patch(
FieldInspections,
Defaults(FieldInspections),
{
Title: TextInput_Title.Text,
Location: TextInput_Location.Text,
Notes: TextInput_Notes.Text,
InspectionPhoto: varCapturedPhoto
}
)
For SharePoint, you'll want to use the Attachments control (covered below) or trigger a Power Automate flow. Keep that in mind as we move forward.
The Camera control is great for capturing something right now. But sometimes users already have the photo they need — it's in their camera roll, their downloads folder, or shared to them via another app. The Add Picture control opens the device's file browser or photo gallery, letting users select an existing file.
It's also worth noting that on some devices or browsers, the Camera control doesn't work as expected (browser permissions, corporate device policies), so Add Picture serves as a reliable fallback.
In Power Apps Studio, click Insert, search for "Add picture," and add it to your screen. You'll see it renders as a button with a default label like "Tap or click to add a picture."
The Add Picture control (formally called Add media or AddMediaButton depending on version) works slightly differently from Camera: instead of a Photo property, it exposes a Media property that contains the selected file. When the user taps the button and selects a file, AddMediaButton1.Media holds that file.
Similar to Camera, you'll want to store this in a variable. Set the OnChange property of the Add Picture control to:
Set(varUploadedPhoto, AddMediaButton1.Media)
Then display it in an Image control just like before:
varUploadedPhoto
Tip: The Add Picture control lets you restrict which file types users can select. In the Properties panel, look for the
AcceptedFileTypesorMediaTypeproperty. Set it toImageto limit users to photos, which prevents someone from accidentally trying to upload a PDF as an "inspection photo."
In a real app, you'll often want both options. A good pattern is to show two buttons side by side: "Take Photo" (which activates the Camera control — you can toggle its Visible property) and "Choose from Library" (which is the Add Picture button). Then both funnel into the same variable:
For Camera's OnSelect:
Set(varPhotoToSubmit, Camera1.Photo)
For Add Picture's OnChange:
Set(varPhotoToSubmit, AddMediaButton1.Media)
Your submission logic then always references varPhotoToSubmit, regardless of how the image was obtained. Clean and simple.
If your app is saving data to a SharePoint list, the Attachments control is almost always the right answer for file handling. Here's why: SharePoint has a native concept of "list item attachments" — files stored directly alongside a list record. The Attachments control is purpose-built to work with this system. It handles multiple files, file naming, upload progress, and deletion all out of the box. You don't need Power Automate flows or base64 conversion.
The downside is that it only works with SharePoint (not Dataverse, SQL, etc.) and it must be used alongside a Form control, not a standalone Patch call.
The Attachments control is designed to work inside a Power Apps Form control (the EditForm or DisplayForm controls) — not as a standalone element. Here's how to set it up properly:
Step 1: Add a Form control to your screen if you don't have one. Click Insert → Forms → Edit Form. Connect it to your SharePoint list by clicking the data source dropdown in the Properties panel.
Step 2: Once your Form is connected to your SharePoint data source, click on the form and look at the Fields panel on the right side. Click Add field and look for the "Attachments" field — SharePoint lists always have an Attachments column built in. Add it to the form.
Step 3: Power Apps automatically inserts an Attachments control into your form card. It appears as a file drop zone with an "Attach file" button.
Step 4: That's it. The Attachments control is wired up. When the user submits the form using a SubmitForm(Form1) call, the attached files are automatically saved as attachments to the newly created or updated list item.
Add a Button control to your screen and set its OnSelect to:
SubmitForm(Form1)
Preview the app, fill in the form fields, click "Attach file," select a file from your device, and click the Submit button. Navigate to your SharePoint list in a browser, open the newly created item, and you'll see the file listed under "Attachments." That's the whole flow working end to end.
Warning: The Attachments control requires that the SharePoint list has "Attachments" enabled. By default SharePoint lists do enable attachments, but if yours doesn't show the Attachments field, check the list settings in SharePoint (List Settings → Advanced Settings → Attachments → Enabled).
Let's put this all together with a realistic end-to-end example. You're building a field inspection form for a facilities management team. The form captures: Inspector Name, Location, Issue Description, Severity, and one or more photos of the problem.
Create a SharePoint list called FacilityInspections with these columns:
Title (single line text) — for the inspector nameLocation (single line text)IssueDescription (multiple lines of text)Severity (choice: Low, Medium, High)In Power Apps Studio, create a new Canvas App (phone or tablet layout depending on your team's devices). Add a Form control connected to the FacilityInspections list.
Add these fields to the form: Title, Location, IssueDescription, Severity.
Then add the Attachments field through the Fields panel. The Attachments control will appear at the bottom of the form.
Add a Camera control above the Attachments control. Set its OnSelect to:
Set(varLatestPhoto, Camera1.Photo)
Add a small Image control next to the Camera to preview the captured photo:
// Image property of the preview Image control:
varLatestPhoto
Now add a Button labeled "Add Camera Photo to Attachments." Here's the clever part — you can't directly inject a camera photo into the Attachments control programmatically in the same way. The recommended pattern is to use the Attachments control for file uploads and the Camera control for a separate "photo of the scene" that gets sent via a Power Automate flow or stored in a different way.
Tip: For many real-world apps, a pragmatic split works well: use the Attachments control for document uploads (PDFs, Word files, existing photos from the gallery) and use a Camera control whose output gets sent to Power Automate to save it to a SharePoint document library as a separate record. This gives you the best of both worlds.
Add a Submit button:
// OnSelect:
SubmitForm(Form1);
Navigate(SuccessScreen, ScreenTransition.Fade)
Build a simple "Damage Report" app for a property management scenario. Here are your requirements:
Setup:
DamageReports with columns: Title, PropertyAddress, DamageDescription, and the default Attachments column.App:
2. Create a new Canvas App (tablet layout).
3. Add an Edit Form connected to DamageReports.
4. Add all four fields plus the Attachments field to the form.
5. Add a Camera control to the screen below the form. Set its OnSelect to store the photo in a variable called varDamagePhoto.
6. Add an Image control with its Image property set to varDamagePhoto so users see their captured photo.
7. Add an Add Picture control so users can also upload existing photos. Store the result in the same varDamagePhoto variable.
8. Add a Submit button that calls SubmitForm(Form1).
9. Add a success label that appears (Visible property set to a boolean variable) after submission saying "Report submitted successfully."
Stretch goal: Add a Reset button that clears the form (ResetForm(Form1)) and sets varDamagePhoto back to blank (Set(varDamagePhoto, Blank())).
"The camera shows in the editor but nothing happens when I click it." The camera only functions in Preview mode (press F5 or the Play button) or when running on a real device. The static editor won't activate the device camera. Also check browser permissions — Chrome will prompt you to allow camera access the first time.
"I captured a photo but it disappeared when I navigated to another screen."
This is the most common mistake. If you only stored the image in Camera1.Photo without calling Set(), it's gone the moment the control is out of scope. Always save to a variable with Set() immediately in the OnSelect.
"The Attachments control isn't appearing in my form's field list." Two things to check: First, make sure your SharePoint list has Attachments enabled (List Settings → Advanced Settings). Second, make sure you're using an Edit Form control connected to SharePoint, not a custom form built from individual controls.
"My Add Picture control only lets users pick photos, not PDFs."
Check the MediaType property of the Add Picture control. If it's set to Image, it restricts to image files. Set it to Mixed to allow documents as well.
"Users on iOS can't access the camera." iOS requires explicit permission prompting through the native app. If you're running the app through a browser (not the Power Apps mobile app), the camera may be blocked by browser security settings. Direct users to download the Power Apps mobile app from the App Store, which handles permissions properly.
"I used Patch() to save the photo but the image column in SharePoint is blank." SharePoint's native columns don't accept raw base64 image data from Patch in the same way Dataverse does. For SharePoint, use the Attachments control with a Form, or send the image to Power Automate to be converted and saved to a document library.
You now understand the three main tools for handling images and files in Canvas Apps, and — crucially — you understand why each one works differently. The Camera control captures live photos into a temporary variable. The Add Picture control lets users select existing files. The Attachments control connects natively to SharePoint list records and is the most robust choice when your data source is SharePoint.
The central lesson underneath all of this is that images in Power Apps are in-memory objects. Your job as a maker is to capture them from a control, hold them in a variable, and deliberately push them to a data source — nothing saves itself automatically.
Where to go next:
Learning Path: Canvas Apps 101