Power Apps Camera and Attachment Controls: Adding Photo Capture and File Uploads to Canvas App Forms

Introduction

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:

• How the Camera control captures images and where that image data goes
• How the Add Picture control works for selecting photos from a device gallery
• How the Attachments control connects to SharePoint to save files with list records
• How to store a captured photo in a SharePoint list using the Patch function
• Common mistakes that cause images to disappear or fail to save

---

Prerequisites

Before diving in, you should be comfortable with:

• Opening Power Apps Studio and creating a basic Canvas App
• Adding controls to a screen and setting basic properties
• A foundational understanding of how SharePoint lists work as a data source
• Basic familiarity with the 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.

---

Understanding How Images Work in Power Apps

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.

---

The Camera Control: Capturing Live Photos

Adding the Camera Control

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.

How the Camera Control Actually Works

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.

Storing the Captured Photo

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.

Saving the Photo to SharePoint

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).

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 Add Picture Control: Uploading Existing Photos and Files

When to Use Add Picture Instead of Camera

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.

Adding the Add Picture Control

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.

Capturing the Selected 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

Combining Camera and Add Picture

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.

---

The Attachments Control: The Right Tool for SharePoint

Why Attachments Is Often the Best Choice

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.

Setting Up the Attachments Control

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.

Testing the Attachment Flow

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.

---

Building a Complete Field Inspection Form

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.

The Data Layer

Create a SharePoint list called FacilityInspections with these columns:

• Title (single line text) — for the inspector name
• Location (single line text)
• IssueDescription (multiple lines of text)
• Severity (choice: Low, Medium, High)
• Attachments — already exists on every SharePoint list

The Screen Layout

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.

Add a Submit button:

// OnSelect:
SubmitForm(Form1);
Navigate(SuccessScreen, ScreenTransition.Fade)

---

Hands-On Exercise

Build a simple "Damage Report" app for a property management scenario. Here are your requirements:

Setup:

1. Create a SharePoint list called 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())).

---

Common Mistakes & Troubleshooting

"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.

---

Summary & Next Steps

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:

• Power Automate integration: Learn how to send a captured photo from Power Apps to a Power Automate flow, which converts it and saves it to a SharePoint document library — this unlocks scenarios the Attachments control alone can't handle.
• Dataverse image columns: If your organization is using Dataverse instead of SharePoint, explore how Dataverse's native image column type works with the Camera control for a cleaner integration.
• Multi-photo capture: Build a gallery of captured photos by using a Collection instead of a single variable, allowing users to capture multiple shots in one session.
• Offline capabilities: Explore how to handle photo capture when the device is offline, caching images locally and syncing when connectivity returns.