That mistake taught me why a Dataverse solution exists in the first place.

A solution is the container that holds your tables, apps, flows, and other components together. It’s how you move your work from a development environment to test, and then to production, without losing anything along the way.

In this tutorial, I’ll walk you through what a Dataverse solution is, why you need one, how to create a solution with a proper publisher, how to add components to it, and how to export and import it between environments the right way.

The sample setup we’ll use throughout this guide

To keep things practical, I’ll use a real example: an IT Helpdesk app built on Microsoft Dataverse. This is the kind of small business app I build for clients all the time, and it’s a perfect fit for showing how solutions work.

Our app is built on a Dataverse table called Tickets, with these columns:

Here’s what the sample data in our Tickets table looks like:

I’ll refer back to this Tickets table and its sample rows throughout this article. Every screen, every component, and every solution I describe below is built around this same IT Helpdesk app, so nothing feels abstract.

If you haven’t worked with Dataverse tables before, it helps to first read what is Microsoft Dataverse and how to create a table in Dataverse before jumping into solutions.

What is a Dataverse solution?

A Dataverse solution is a container that packages your customizations — tables, columns, forms, views, canvas apps, model-driven apps, and Power Automate flows — into one transportable unit.

Think of it like a box you pack before moving houses. Instead of carrying your table, your app, and your flow separately from one environment to another, you put them all in one box (the solution) and move the whole box at once.

Every customization you make in Dataverse lives inside a solution, whether you create one on purpose or not. If you don’t pick a solution, Microsoft dumps your work into the default solution, which is a shared, messy container you should never rely on for real projects.

Pro Tip: I’ve lost count of how many client environments I’ve inherited where everything was built in the default solution. Untangling components from the default solution later is painful and sometimes impossible. Create a custom solution before you build anything — even a single table.

Why you need a custom solution (not the default one)

The default solution contains every component in your environment, including things you didn’t build yourself. That makes it useless for moving just your app to another environment.

A custom solution only contains what you explicitly add to it. This gives you a clean, predictable package that you control completely.

This matters most when you’re doing application lifecycle management (ALM) — the process of moving your work from development, to test, to production in a structured way.

If you’re still deciding between SharePoint and Dataverse as your data source, I’d recommend reading Power Apps Dataverse vs SharePoint list first. Solutions are one of the biggest reasons teams choose Dataverse over SharePoint for serious business apps.

Managed vs unmanaged solutions: what’s the difference?

This is the concept that trips up almost every beginner, so let’s slow down here.

Unmanaged solutions are open for editing. You can freely add, change, or remove components inside them. You build and develop inside unmanaged solutions.

Managed solutions are locked packages meant for deployment. Once you import a managed solution into an environment, users can’t directly edit its components there.

Here’s the rule I follow on every single project: develop unmanaged, deploy managed.

You build your Tickets table, your forms, and your canvas app inside an unmanaged solution in your development environment. When you’re ready to move it to test or production, you export that solution as managed, then import the managed version into the target environment.

Pro Tip: In my experience, teams that skip this pattern and import unmanaged solutions straight into production almost always regret it. Someone eventually opens the solution in production and tweaks a column directly, and now your dev and production environments no longer match.

Why managed solutions protect production

When you import a managed solution, its components become locked in that environment. People can still use the Tickets app and submit tickets normally.

But they can’t change the Status choice values, rename columns, or edit the form layout directly in production. That protection prevents accidental changes that could break the app for everyone.

Deleting a managed solution also removes all its components from that environment, which can mean data loss. Deleting an unmanaged solution only removes the container — the tables and data stay behind. Keep this difference in mind before you delete anything.

Step 1: Create a custom publisher

Before you create your first solution, you need a publisher. A publisher represents who built the solution and adds a prefix to every component you create.

Here’s how I set one up for the IT Helpdesk project:

1. Go to make.powerapps.com and select your environment.
2. Click Solutions in the left navigation.
3. Click New solution, then select New publisher from the Publisher dropdown.
4. Enter a Display name (for example, “Contoso IT Team”).
5. Enter a Name (no spaces, for example, “ContosoIT”).
6. Set a Prefix — a short code like “cit” that gets added before every table and column you create (for example, cit_tickets, cit_priority).
7. Click Save and Close.

That prefix matters more than it looks. Every custom table, column, and choice you build gets this prefix automatically, so cit_tickets immediately tells anyone on the team that this table came from your Contoso IT publisher, not from another team’s solution.

Pro Tip: Never use the default publisher for real projects. I once worked on an environment where three different teams had all used the default publisher, and their table prefixes were indistinguishable. Picking apart ownership took hours we didn’t have.

Step 2: Create the solution

With the publisher ready, creating the actual solution takes less than a minute.

1. Still in Solutions, click New solution.
2. Enter a Display name, like “IT Helpdesk Solution.”
3. Choose the publisher you just created from the dropdown.
4. Set a Version number, such as 1.0.0.0.
5. Click Create.

Your solution now exists as an empty container, ready for components. Version numbers matter for tracking changes over time, so I always bump the version before every export I plan to move somewhere.

Step 3: Add components to your solution

Now it’s time to add the actual pieces of your IT Helpdesk app to the solution.

Inside your new solution, click Add existing, then choose the type of component you want to add:

• Table — Select your Tickets table (or use create table from SharePoint list if you’re migrating from SharePoint).
• Canvas app — Select the IT Helpdesk canvas app you built on top of the Tickets table.
• Cloud flow — Select any Power Automate flow that emails a technician when a new ticket is raised.
• Choice — Include any global choices you created, like Status or Priority, if they aren’t already part of the table.

When you add the Tickets table, Dataverse asks if you want to include all subcomponents, like forms, views, and business rules. I usually add only what I’m actively customizing to keep the solution clean, following the “segmenting” principle — smaller, focused solutions are easier to manage than one giant solution with everything in it.

If your Tickets table needs a calculated field, this is a good point to also learn about the Dataverse formula column, which you can add straight into the same solution.

Building the canvas app inside the solution

Once your Tickets table is in the solution, you can build your canvas app directly from within it.

1. Inside the solution, click New > App > Canvas app.
2. Choose Tablet format, then connect it to your Tickets table.
3. Add a Gallery control that shows all open tickets, sorted by DueDate.
4. Add a Form control set to New form mode for submitting new tickets.

The Gallery pulls records straight from our sample Tickets data. Set the gallery’s Items property to a filter like this:

Filter(Tickets, Status.Value = "Open")

Using our sample rows, this formula returns “VPN not connecting,” “New laptop request,” and “Printer offline” — every row where Status equals Open. The “Password reset needed” ticket, marked Resolved, correctly drops out of the view.

If you want a search box on top of that gallery, check out filter Power Apps gallery search box for the exact formula pattern.

To save a new ticket from the form back to Dataverse, use:

SubmitForm(NewTicketForm)

This one line submits whatever the user filled into the form and creates a new row in the Tickets table, following the same column structure as our sample data. If you’d rather write directly to specific fields without a form control, look at Patch Dataverse number field in Power Apps for a Patch-based approach instead.

Pro Tip: Always build your canvas app from inside the solution, not from the general Power Apps home page. Apps built outside a solution get dropped into the default solution automatically, and you’ll have to manually move them back in later.

Step 4: Publish your customizations

After adding or editing components, always click Publish all customizations before you test or export.

Dataverse holds your changes in a draft state until you publish them. Skipping this step is one of the most common reasons a canvas app doesn’t reflect a column you just added to the Tickets table.

I make this a habit: build a component, publish, test, then move to the next component. It catches errors early instead of letting five unpublished changes pile up.

Step 5: Export the solution

Once your IT Helpdesk solution is built and tested in your development environment, it’s time to export it.

1. Open Solutions, and select your IT Helpdesk solution.
2. Click Export solution.
3. Choose whether to export it as Managed or Unmanaged.
4. Click Export, and Dataverse downloads a .zip file to your computer.

For moving to test or production, always choose Managed. Keep your working copy unmanaged in development, and only export a managed copy when you’re ready to deploy.

Pro Tip: I always bump the solution’s version number before exporting. A version history like 1.0.0.1, 1.0.0.2, and 1.0.0.3 tells me and my team exactly what shipped and when, which saves a lot of guesswork during troubleshooting later.

Step 6: Import the solution into another environment

With your managed .zip file ready, importing it into your test or production environment is straightforward.

1. Go to make.powerapps.com and switch to the target environment.
2. Click Solutions, then Import solution.
3. Browse to your exported .zip file and select it.
4. Review any connection references or environment variables Dataverse asks you to configure.
5. Click Import.

Dataverse validates the package, checks for missing dependencies, and installs the Tickets table, the canvas app, and the flow together, exactly as they existed in development.

If your solution includes a flow that connects to an external system, you’ll be asked to set up connections again in the new environment, since credentials don’t travel inside the solution package.

Solution layering: how Dataverse handles multiple solutions

Once you start deploying managed solutions regularly, it helps to understand solution layering.

Dataverse organizes solutions into two layers: the unmanaged layer, where all unmanaged solutions and customizations live, and the managed layer, where managed solutions and the core system solution live.

When you install a second managed solution that touches the same component as an earlier one, the newer managed solution sits on top and controls the current behavior. If you later uninstall it, the layer underneath takes over again.

This layering is exactly why Microsoft recommends keeping your solution structure simple, and why I avoid creating multiple overlapping solutions that touch the same tables. It adds a layer of complexity most small teams don’t need.

Patching a solution instead of re-exporting everything

If you only need to add one new column to the Tickets table, you don’t have to export the entire solution again. You can create a solution patch.

A patch is a smaller solution tied to your main solution’s version, containing only the new or changed components. It gets deployed on top of the original, keeping your deployment history clean and your packages small.

I use patches constantly for small tweaks like adding a new Choice value or fixing a form layout, saving the full solution re-export for bigger releases with several new components.

Things to keep in mind with Dataverse solutions

• Always use a custom publisher. Never build on the default publisher or default solution — it makes ownership and prefixes impossible to track later.
• Segment your solutions. Only add the components you’re actively changing. Including everything “just in case” creates bloated, hard-to-manage solutions.
• Watch for missing dependencies on import. If your solution references a table or choice that doesn’t exist in the target environment, the import will fail until you fix the dependency chain.
• Reconfigure connection references after import. Flows and connectors don’t carry credentials across environments, so budget time to reset these after every deployment.
• Don’t edit managed solutions directly in production. If you need a change, make it in development, then re-export and re-import — resist the temptation to “quickly” unlock and edit it live.
• Version your solutions consistently. A clear version number scheme makes rollback and troubleshooting far easier when something breaks after a deployment.

Frequently Asked Questions

If there’s one sequence I want you to remember from this tutorial, it’s this: create a custom publisher first, build your Tickets table and canvas app inside a custom unmanaged solution, publish your changes, then export as managed for anything outside development.

Following that order in that exact sequence saves you from the exact mistake I made on my first project — building loose in the default solution and paying for it later. Build this habit early, and every future deployment will feel a lot less stressful.

You may also like the following tutorials:

• What is Microsoft Dataverse?
• Power Apps Dataverse vs SharePoint List
• Migrate SharePoint Online List to Dataverse
• Dataverse Create Table from SharePoint List
• Preferred Solution in Power Platform

That’s the exact problem Microsoft Dataverse was built to solve.

If you’ve been building Canvas apps on SharePoint lists and you’re starting to feel the limits — slow galleries, messy relationships, weak security — Dataverse is probably the next tool you need to learn.

In this guide, I’ll walk you through what Dataverse actually is, how it’s structured, and how to create your first table using a real example.

The Sample Data We’ll Use Throughout This Guide

Let’s ground this in something real instead of abstract theory. Say you’re building an IT Service Desk app for internal support tickets.

In Dataverse, you’d create a table called Tickets. A table in Dataverse is the same idea as a list in SharePoint or a sheet in Excel — it’s where your records live.

Here are the columns (Dataverse calls fields “columns,” same as SharePoint):

• Title (text) — short description of the issue
• Status (choice) — New, In Progress, Resolved
• Priority (choice) — Low, Medium, High
• Due Date (date and time)
• Assigned To (lookup to the Users table)
• Category (choice) — Hardware, Software, Network, Access

Here’s what a handful of sample rows would look like:

I’ll keep referring back to this Tickets table as we go, so every concept has a real anchor instead of floating in theory.

What Is Microsoft Dataverse, Exactly?

Microsoft Dataverse is a cloud-based data platform that sits underneath the entire Power Platform — Power Apps, Power Automate, Power BI, and Copilot Studio.

Think of it as a secure, structured database that’s already built for business applications. You don’t manage servers, write SQL to set it up, or worry about backups.

Microsoft describes it as the data platform that lets you securely store and manage the data used by your business applications. That’s the whole point — one place for your data, many apps built on top of it.

When you build a Canvas app or a Model-driven app in Power Apps, Dataverse is usually the recommended data source, especially once your app grows past a simple list.

Pro Tip: In my experience, teams often start on SharePoint because it’s free and familiar, then hit a wall around 5,000–10,000 items or when they need real relationships between lists. That’s usually the trigger to move to Dataverse.

Why Not Just Use SharePoint or Excel?

This is the question I get most from clients. SharePoint and Excel work fine for simple tracking. They fall apart when your app needs to scale or handle real business logic.

SharePoint lists don’t enforce strict data relationships. You can build lookup columns, but they’re fragile and break easily during migrations.

Excel has no real concurrency control. Two people editing the same file at once is a recipe for lost data.

Dataverse was designed from the ground up to avoid these problems. It has proper relational tables, row-level security, and built-in business logic — not workarounds bolted onto a document library.

I’ve written a full breakdown comparing the two if you want the detailed trade-offs: Power Apps Dataverse vs SharePoint List.

The Core Building Blocks of Dataverse

Dataverse has its own vocabulary. Once these five concepts click, the rest of the platform makes a lot more sense.

Tables

A table is a collection of rows and columns, just like our Tickets example above. Dataverse ships with standard tables (Account, Contact, User) and lets you create custom tables for your own business needs.

If you’re bringing over an existing list, this guide walks through the exact process: Migrate a SharePoint Online List to Dataverse.

Columns

Columns define what kind of data each field holds — text, number, date, choice, lookup, image, and more. Every table needs a primary name column, which is the main identifier shown in lookups and views.

For our Tickets table, that primary column would be Title. I’ve got a separate walkthrough on customizing this behavior here: Dataverse Primary Name Column Autonumber.

Choices

Choice columns are Dataverse’s version of SharePoint’s choice field — a dropdown with a fixed set of options. Our Status and Priority columns are both choices.

The difference is that Dataverse choices can be reused across multiple tables, which SharePoint choice columns can’t do easily. See Power Apps Dataverse Choices for the full setup.

Relationships

This is where Dataverse really pulls ahead of SharePoint. Table relationships let you connect tables properly — one ticket to one assigned user, one user to many tickets.

Our Assigned To column is a lookup, which creates a relationship between Tickets and the Users table. That relationship stays intact even as data grows into the millions of rows.

Business Rules and Formula Columns

Business rules let you apply logic without writing code — for example, automatically setting Priority to High whenever Category is “Network.” Formula columns calculate values automatically, similar to an Excel formula but stored right in the table.

If you want to see formula columns in action, check out Dataverse Formula Column.

How Dataverse Connects to the Rest of the Power Platform

The real value of Dataverse isn’t the table itself — it’s how many tools can plug into the same data.

Your Canvas app can read and write to the Tickets table directly using Power Fx, the formula language behind Power Apps. Here’s a simple example of adding a new ticket with Patch:

Patch(
    Tickets,
    Defaults(Tickets),
    {
        Title: TextInputTitle.Text,
        Status: 'Status (Tickets)'.New,
        Priority: 'Priority (Tickets)'.Medium,
        Category: 'Category (Tickets)'.Software
    }
)

Notice the choice values are written as 'Status (Tickets)'.New instead of plain text. That’s because Dataverse choices are strongly typed — the app needs to reference the exact choice set name.

If you’re building the read side of this, this tutorial covers it well: Get Data from Dataverse in Power Apps.

Power Automate flows can watch the same Tickets table and trigger notifications the moment a new high-priority ticket lands. See Power Automate Dataverse Add New Row for that trigger pattern.

Power BI connects natively too, so you can build a live dashboard of open tickets by category without exporting anything. I cover that connection here: Dataverse Power BI.

Pro Tip: I always tell junior developers — build the table structure right the first time. Every downstream tool (flows, dashboards, apps) inherits whatever structure you define in Dataverse, so fixing it later means touching everything connected to it.

Environments and Security in Dataverse

Every Dataverse database lives inside an environment — a container that groups your apps, flows, and data for a specific purpose (like Development, Test, or Production).

This matters because it lets you test changes safely before pushing them to the environment your whole team uses.

Security in Dataverse works through security roles, which control exactly what each user can see and do — down to the individual column level if needed. This is far more granular than SharePoint’s site permissions.

For example, you could let support agents view and edit Tickets, but only let managers change the Priority field. That kind of fine-grained control just isn’t possible with a standard SharePoint list.

How to Create Your First Dataverse Table

Let’s actually build the Tickets table so this isn’t just theory.

1. Open Power Apps and go to Tables under the Dataverse section in the left navigation.
2. Click “New table” and choose “Standard” so you get built-in system columns like Created On and Modified By.
3. Name your table Tickets and give it a clear description. Dataverse will auto-generate the primary column for you.
4. Add your columns one by one — Status, Priority, Due Date, Category, and the Assigned To lookup — matching data types to what your data actually needs.
5. Save and create a view so you can see your data in a grid immediately.

For a step-by-step version of this with screenshots-level detail, see Dataverse Create Table. And once your table exists, you’ll want a filtered view for your app — Dataverse Create View covers exactly that.

If you’d rather bring in existing data instead of starting from scratch, both of these are common paths:

• Dataverse Create Table from SharePoint List
• Power Apps Create Dataverse Table from Excel

Dataverse vs SharePoint: A Quick Gut-Check

I’m not going to repeat the full comparison here since I’ve already linked the dedicated article above, but here’s my honest, condensed take.

Choose SharePoint when your app is simple, your team is small, and you don’t need complex relationships or row-level security.

Choose Dataverse when you’re building something that needs to scale, needs proper security roles, or needs to connect cleanly to Power BI and multiple apps at once.

Our Tickets example genuinely fits Dataverse well — support tickets grow fast, need relationships to users, and often need reporting.

Things to Keep in Mind with Dataverse

• Licensing isn’t free like SharePoint. Dataverse typically requires a Power Apps per-app or per-user license, so budget for this before committing a client to it.
• Choice sets are shared across tables by default. Renaming a global choice can quietly affect every table using it — always check dependencies first.
• Solutions matter for real projects. Don’t build tables directly in your default environment for production work. Use a proper Dataverse Solution so you can move changes cleanly between environments.
• Delegation limits still apply in Canvas apps. Even with Dataverse’s better performance, formulas like Filter and Search still need to be delegable, or you’ll only work against a subset of your data.
• Security roles take planning time. Don’t skip this step to save time early — retrofitting security roles onto live data is far more painful than designing them upfront.
• Version history has a retention window. Dataverse keeps version history for auditing, but it’s not a substitute for a real backup strategy.

Frequently Asked Questions

If there’s one thing I want you to take from this article, it’s that Dataverse isn’t just “SharePoint but fancier.” Start by learning tables and columns, then relationships, then security roles — in that order.

That sequence matters because each layer builds on the last, and skipping straight to security roles before understanding your table structure almost always means redoing work later. Good luck building your first table.

You May Also Like the Following Tutorials

• Power Apps Dataverse vs SharePoint List
• Migrate a SharePoint Online List to Dataverse
• Standard vs Premium Connectors in Power Apps
• Power Apps Dataverse Choices
• Dataverse Solution

Employees asked simple questions like, “How many annual leave days do I get?”, “Can I work from home?”, and “How do I submit an expense claim?” The agent had the information, but I still needed to control how it answered those questions.

That is where Agent Instructions and Conversation Starters became important. In this guide, I will show you how I configure Agent Instructions in Microsoft Copilot Studio, add an HR policy PDF as knowledge, create useful conversation starters, test the agent, and publish it for users.

What Are Agent Instructions in Microsoft Copilot Studio?

I think of Agent Instructions as rules I give to my agent.

Knowledge gives the agent information, but instructions tell the agent how I want it to use that information.

For example, I may want my HR assistant to:

• Answer only HR-related questions.
• Use simple and professional language.
• Give short answers unless the user asks for details.
• Give numbered steps when explaining a process.
• Never make up company policies.
• Tell employees when information is unavailable.
• Ask a question when the employee’s request is unclear.
• Avoid sharing confidential employee information.

Without clear instructions, the agent may still answer questions, but I have less control over its behavior.

The easiest way I remember these concepts is:

• Knowledge = What my agent knows
• Instructions = How my agent behaves
• Conversation Starters = What I help users ask

If you are completely new to Copilot Studio, you can first learn how to create an agent using Microsoft Copilot Studio.

My Example: Employee HR Assistant

For this tutorial, I am using an Employee HR Assistant. I like this example because it is close to a real business requirement.

Imagine I am working with a company that has around 200 employees. The HR team gets the same questions every week.

Employees ask things like:

• How many annual leave days do I get?
• What is the sick leave policy?
• Can I work from home?
• What are the standard working hours?
• How do I submit an expense claim?
• What are the company holidays?
• How can I contact HR?

Instead of asking HR to answer these basic questions every time, I can create an HR assistant using Microsoft Copilot Studio.

The assistant will answer questions based on company HR information.

I can also use this Smart HR Assistant using Copilot Studio example if I want to explore a complete HR chatbot scenario later.

Create the Employee HR Assistant

First, I open Microsoft Copilot Studio and create a new agent.

For my example, I use:

Name: Employee HR Assistant

For the description, I enter:

An AI assistant that helps employees find information about company HR policies, leave, work from home, holidays, expenses, and common HR questions.

This description gives Copilot Studio a basic idea about what I want to build. However, I do not depend only on the description.

After creating the agent, I configure its Knowledge, Instructions, and Conversation Starters separately.

This gives me better control over the final experience.

Add an HR Policy PDF as Knowledge

The next thing I do is give my agent company-specific information.

For this example, I created an Employee HR Policy Handbook PDF.

My document contains information about:

• Annual leave
• Sick leave
• Casual leave
• Work-from-home policy
• Working hours
• Company holidays
• Expense reimbursement
• Employee benefits
• HR support

Inside my agent, I go to Knowledge and add the HR Policy Handbook.

After Copilot Studio processes the document, my agent can use that information when employees ask HR-related questions.

For example, if my PDF says:

Full-time employees receive 18 working days of annual leave per calendar year.

Then an employee can ask:

How many annual leave days do I get?

The agent can use the HR Policy Handbook to answer that question.

This is why I say:

Knowledge tells the agent what it knows.

PDF Knowledge vs SharePoint Knowledge

A PDF works very well for my demo because it is simple.

But in a real company, HR policies may already be stored in SharePoint.

In that case, I may use SharePoint instead of manually maintaining several PDF files.

For example, I can use a SharePoint list as knowledge in Copilot Studio when my information is stored in a structured list.

I usually choose the source based on where the business already maintains its information.

If HR already updates policies in SharePoint, I do not want them to maintain another copy only for the agent.

Why Knowledge Alone Is Not Enough

This is something I always explain when I show Copilot Studio to beginners.

Suppose I upload the HR Policy Handbook.

Now my agent knows about annual leave, working hours, expenses, and other HR policies.

But the document does not tell my agent:

• How long its answers should be.
• Whether answers should be formal or friendly.
• What to do when the answer is missing.
• Whether it should make assumptions.
• How it should answer process-related questions.
• What to do when someone asks a non-HR question.

That is why I configure Agent Instructions.

The HR document contains the business information.

My instructions define the behavior.

Keeping these two things separate also makes the solution easier for me to manage later.

If HR changes the annual leave policy, I update the knowledge source.

I do not need to rewrite the agent’s behavior rules.

How I Configure Agent Instructions in Copilot Studio

Now I open my agent’s Instructions section.

I may already see some instructions created when I first created the agent.

I review them carefully.

I do not recommend using an instruction like this:

You are an HR assistant. Answer HR questions.

It is too basic.

It tells the agent what its role is, but it does not tell the agent enough about how I want it to behave.

For my Employee HR Assistant, I use something like this:

You are the Employee HR Assistant.

Your primary responsibility is to help employees understand company HR policies and procedures.

Answer questions related to leave policies, work-from-home policies, company holidays, working hours, expense reimbursement, employee benefits, and general HR procedures.

Use the configured HR knowledge sources when answering company policy-related questions.

Do not invent company policies, leave allowances, reimbursement limits, dates, or HR rules.

If the requested information is not available in the configured knowledge sources, clearly tell the employee that you could not find the information and recommend contacting HR.

Use simple and professional language.

Keep answers concise unless the employee asks for more details.

When explaining a process, provide numbered step-by-step instructions.

If the employee's question is unclear, ask a clarifying question before providing an answer.

Do not provide legal, medical, or financial advice.

Never expose confidential information belonging to another employee.

If the employee asks something unrelated to HR, explain that you are an HR assistant and ask them to provide an HR-related question.

I like this format because every instruction has a clear purpose.

How I Structure My Agent Instructions

When I write instructions, I normally break them into a few simple areas.

1. Define the Agent’s Role

First, I tell the agent what it is.

For example:

You are the Employee HR Assistant for Contoso.

This gives the agent a clear identity.

2. Define What the Agent Should Answer

Next, I define its scope.

For example:

Answer questions related to leave, work from home, working hours, company holidays, expenses, benefits, and HR procedures.

I do this because I do not want my HR assistant answering every possible question.

If somebody asks:

Write JavaScript code for me.

that request has nothing to do with my HR agent.

3. Tell the Agent Which Information to Trust

I also tell it:

Use the configured HR knowledge sources when answering company policy-related questions.

This is especially important for company-specific information.

For example, I do not want the agent using a general answer about how many annual leave days employees normally receive.

I want it to use my company’s policy.

4. Tell the Agent Not to Guess

This is one of the most important instructions I use.

I tell the agent:

Do not invent company policies, leave allowances, reimbursement limits, dates, or HR rules.

If my HR document does not contain a maternity leave policy, I would rather see:

I could not find this information in the available HR resources. Please contact HR.

That is much better than showing an employee a made-up company rule.

5. Define the Response Style

I also tell the agent how I want its answers to look.

For example:

Use simple and professional language.

and:

Keep answers short unless the employee asks for more details.

I have found this useful because employees normally want quick answers.

They usually do not want five long paragraphs for a simple question like:

What are our working hours?

6. Tell the Agent How to Explain Processes

For process-related questions, I use:

When explaining a process, provide numbered step-by-step instructions.

This works well for questions such as:

How do I apply for annual leave?

or:

How do I submit an expense reimbursement claim?

Instead of one large paragraph, I want the answer to look more like:

1. Open the employee portal.
2. Select the leave request option.
3. Choose the leave type.
4. Enter the start and end dates.
5. Submit the request.

That is much easier for the employee to follow.

Pro Tip: I’ve found that simple instructions usually work better than a large block of complicated rules. I tell the agent exactly what I expect and keep company policy details inside the knowledge source.

Test Agent Instructions in Copilot Studio

After configuring the instructions, I always test them.

I do not publish the agent immediately.

I start with a normal HR question.

Test 1: Ask a Policy Question

I ask:

How many annual leave days do I get?

My agent should find the answer from the HR Policy Handbook.

For my example, the answer may say that eligible employees receive 18 annual leave days.

This test tells me whether the agent is using my knowledge correctly.

Test 2: Ask for a Process

Next, I ask:

How do I apply for leave?

This test is important because I specifically told my agent to provide numbered steps for process questions.

I check whether the answer is easy to follow.

If the answer is still too long, I can improve my instructions.

For example:

Keep process instructions concise and provide only the steps required to complete the process.

Test 3: Ask About Missing Information

I also test something that does not exist in my HR Policy Handbook.

For example:

What is our paternity leave allowance?

If that information is not available, I want the agent to tell me it could not find the policy.

I do not want it to guess.

Test 4: Ask an Unrelated Question

I ask:

Can you write Python code for a calculator?

My HR assistant should tell me that it focuses on HR-related questions.

This tells me whether my scope instruction is working.

Test 5: Ask an Unclear Question

Finally, I ask:

Tell me about leave.

This question is very broad.

The agent may ask whether I want information about annual leave, sick leave, casual leave, or the leave application process.

That is exactly why I added this instruction:

If the employee’s question is unclear, ask a clarifying question.

Configure Conversation Starters in Copilot Studio

Now my agent knows how I want it to behave. But I still need to think about the employee using the agent.

Suppose an employee opens Employee HR Assistant for the first time. They may not know what questions the agent can answer.

This is where Conversation Starters, also called Suggested Prompts, become useful.

I use them to show users examples of useful questions.

For my HR assistant, I can configure prompts like these:

I prefer specific prompts like these.

I avoid conversation starters such as:

Help me

or:

Ask HR

Those prompts do not show the employee what the agent can actually do.

If I want to improve the opening experience further, I can also customize the welcome message in Copilot Studio.

Agent Instructions vs Conversation Starters

This is one area where beginners sometimes get confused.

The easiest way I explain it is:

• Instructions are for my agent.
• Conversation Starters are for my users.

For example, this is an instruction:

When explaining a process, use numbered steps.

The employee does not need to know about that rule.

But this is a conversation starter:

How do I apply for leave?

The employee can select that prompt and immediately start a useful conversation.

So I use Instructions to control behavior and Conversation Starters to improve the user experience.

What Happens When Information Changes?

HR information changes over time.

For example:

• Annual leave entitlement may change.
• Work-from-home rules may change.
• Reimbursement limits may change.
• Company holidays change every year.

I do not want to put this changing information directly inside my Agent Instructions.

Instead, I update the HR knowledge source.

For example, if annual leave changes from 18 days to 20 days, I update the source where HR manages that policy.

My behavior instruction can remain:

Use the configured HR knowledge source when answering company policy questions.

This separation makes the agent much easier for me to maintain.

Authentication and Employee Information

For the example in this article, I mainly use company policy information.

That is very different from employee-specific information.

For example:

What is the company’s annual leave policy?

is a general company question.

But:

How many leave days do I personally have remaining?

is a personal question.

If I want my agent to work with employee-specific information, I need to think carefully about authentication and security.

The agent must know who the employee is before showing personal data.

I should never allow Employee A to ask for Employee B’s confidential HR information.

If I need more control over user identity, I can review how to set up manual authentication in Microsoft Copilot Studio.

For my HR assistant, I also include this instruction:

Never expose confidential information belonging to another employee.

The instruction helps define expected behavior, but I still need proper security on the data source itself.

Publish the Employee HR Assistant

Once I am happy with my testing, I publish the agent.

Before publishing, I check:

• Does the agent use the HR knowledge correctly?
• Are responses short and clear?
• Does it avoid inventing company policies?
• Does it handle missing information properly?
• Does it stay within the HR scope?
• Are the conversation starters useful?
• Does it avoid exposing confidential information?

Once those tests pass, I publish the latest version.

I can then make the agent available through the channel my employees will use.

A channel is simply where users interact with my agent.

For example, I may want employees to use it inside the Microsoft 365 experience or another supported channel.

If I am building an agent for a public website instead, I can also follow this guide to publish a Copilot Studio agent to a live website.

For an internal HR assistant, I normally try to place the agent where employees already work. This makes adoption easier because users do not need to learn another system.

Some Useful Tips

• Keep instructions simple. I avoid writing one huge instruction full of complicated rules. Clear instructions are easier to test and maintain.
• Do not copy every policy into Instructions. I keep policy information in the knowledge source and use instructions only for behavior.
• Tell the agent not to guess. I always define what should happen when company-specific information is unavailable.
• Protect employee information. I never depend only on a prompt instruction for security. I also secure the actual data source.
• Test different question types. I test normal questions, unclear questions, missing information, unrelated questions, and sensitive requests.
• Review instructions when policies change. Usually I update the knowledge source, but I still review the overall agent behavior after major business changes.

Frequently Asked Questions

I configured my Employee HR Assistant by combining company knowledge, clear Agent Instructions, and useful Conversation Starters. I have found that keeping knowledge and behavior separate makes the agent much easier to control, test, and maintain.

I hope you found this article helpful.

You may also like

• Create autonomous agents in Microsoft Copilot Studio
• Microsoft 365 Copilot vs Copilot Studio
• Create a custom agent in Microsoft 365 Copilot
• Copilot Studio demo website authentication error
• SharePoint Online overview

I’ve sat on both sides of the table for Power Apps interviews — as a candidate early in my career, and later as someone screening developers for client projects. The questions that separate a strong candidate from an average one are rarely the textbook ones. They’re the “how would you design this” and “why did you choose that approach” questions that show whether you’ve actually shipped apps to production.

This article walks you through 50 Power Apps interview questions and answers, organized by theme, so you can prepare with a clear structure instead of randomly Googling isolated topics.

If you want to become a Power Apps developer, check out the complete training courses or our live training.

Canvas App Design and UI Questions

These questions test whether you can architect an app that’s easy to extend later, not just one that works today.

1. You need to build a multi-lingual Canvas app supporting English, Spanish, and French. How would you design it so adding another language later is easy?

I never hardcode text strings directly on controls. Instead, I build a collection of labels with one column per language, loaded on app start using ClearCollect(), and reference it everywhere with a formula like LookUp(colLabels, Key = "Welcome").EN. A cleaner alternative is a Named Formula or a Dataverse table that stores translations, so adding a new language later means adding a column or a few rows — not touching every screen.

2. How would you build a multi-theme Canvas app where users can switch between Light and Dark themes using a Toggle?

I store theme colors as a collection or a set of global variables (varPrimaryColor, varBackgroundColor, and so on) and bind every control’s Fill and Color property to those variables instead of hardcoded hex values. The Toggle’s OnCheck and OnUncheck just update the variables using Set(). You can read a full walkthrough on switching between light and dark themes with a Power Apps toggle control.

3. How can you download Gallery data from a Canvas App into Excel or CSV?

For a Data table control, I usually use the built-in export feature, or generate a CSV string with Concat() and trigger a download through the Download() function. For anything more formatted, I hand it off to Power Automate to build the file server-side. I’ve covered both approaches in detail in exporting data from a data table to Excel in Power Apps.

Pro Tip: I’ve found that interviewers love this question because it exposes whether you understand governance too. I always mention that exporting sensitive data needs a review of the app’s Data Loss Prevention (DLP) policy before anyone assumes it’s a simple feature request.

4. How do you plan screen navigation in a large Canvas app with many screens?

I avoid a flat list of screens with individual Navigate() calls scattered everywhere. Instead, I build a reusable navigation Component with a collection-driven menu, so adding a new screen means adding one row, not editing ten buttons. I’ve built exactly this kind of setup in creating a responsive navigation menu in Power Apps and a left navigation component.

5. What are Components in Power Apps and why should you use them?

A Component is a reusable group of controls with its own custom properties, similar to a template you drop onto multiple screens. I use them for headers, footers, and navigation menus so a design change happens in one place instead of every screen. Here’s a practical example: creating a header component in Power Apps.

6. How do you build a horizontal navigation menu with submenus in Power Apps?

I nest a horizontal Gallery for top-level menu items and toggle the visibility of a second Gallery for submenu items based on the selected parent item, usually tracked with a context variable. I walk through a complete build in creating a horizontal navigation menu with submenus in Power Apps.

7. How do you make a Canvas app responsive across tablet and mobile screen sizes?

I set container layouts to fill available space, use Parent.Width and Parent.Height instead of fixed pixel values, and test on both orientations early — not after the app is “done.” Getting this wrong is one of the biggest rework causes I’ve seen on client projects.

Power Fx and Formula Questions

This is where interviewers separate people who’ve memorized function names from people who understand Power Fx, the formula language behind Power Apps.

8. What is delegation in Power Apps and why is it important when working with large datasets?

Delegation means the data source (like SharePoint or Dataverse) processes a query itself instead of Power Apps pulling all records down first. Non-delegable formulas only process the first 500 or 2,000 records locally, so a Filter() that isn’t delegable will silently return incomplete results on a large list. I always check the delegation warning icon in the formula bar and rework the formula, or move to Dataverse, when a list starts growing.

9. What is the difference between Patch() and SubmitForm() in Canvas Apps?

SubmitForm() saves whatever is bound to a Form control’s fields, using the form’s own validation rules. Patch() gives you direct, field-level control to insert or update a record without needing a Form control at all, which is useful for Gallery-based editing or saving several records at once. I explain both patterns with examples in Update and UpdateIf in Power Apps and patching Gallery items in Power Apps.

10. What are Named Formulas in Power Apps and how are they different from using Set()?

A Named Formula is a reusable, auto-recalculating value defined once at the app level — similar to a calculated column that always stays current. Set() creates a global variable that only changes when you explicitly run that line of code again. I reach for Named Formulas for values that should always reflect current state, like “is the current user an admin,” and I use Set() for things that genuinely represent one-time user actions, like a button click flag.

11. What is the difference between Collect() and ClearCollect()?

Collect() adds records to an existing collection without removing what’s already there, so calling it repeatedly keeps growing the collection. ClearCollect() empties the collection first and then adds the new records, which is what you want when refreshing data on screen load. I’ve written more on building these from scratch in creating an empty collection in Power Apps and adding Gallery data to a collection.

12. How does UpdateContext() differ from Set()?

UpdateContext() creates a context variable that only exists on the current screen, while Set() creates a global variable available across the whole app. I use context variables for screen-only UI state, like whether a panel is expanded, and global variables for anything the rest of the app needs to see, like the logged-in user’s role.

13. What does the Concurrent() function do and when would you use it?

Concurrent() runs multiple formulas at the same time instead of one after another, which noticeably speeds up app load when you’re pulling from several unrelated data sources. I typically wrap my initial ClearCollect() calls for dropdown lookups inside Concurrent() on the app’s OnStart property.

14. How do you handle errors gracefully in a Canvas app?

I wrap risky operations in IfError() and show a friendly Notify() message instead of letting the app throw a raw error banner at the user. Two errors I run into often are covered in the “does not match the expected type record” error and invalid operation: division by zero in Power Apps.

15. What’s the difference between LookUp() and Filter()?

LookUp() returns a single record — the first match it finds — while Filter() returns a table of every matching record. Using LookUp() when you actually need multiple rows, or using Filter() and then grabbing First() when you only need one record, are both common mistakes I’ve had to fix in code reviews.

16. How do you use the With() function, and why is it useful?

With() lets you define temporary named values inside a single formula, so you don’t have to repeat the same sub-expression multiple times. It also makes formulas easier to read and slightly more efficient, since the sub-expression only gets evaluated once instead of on every reference.

17. How do you optimize a formula-heavy Canvas app for performance?

I move repeated lookups into variables set once on screen load instead of recalculating them on every control. I also avoid nested Filter() calls inside Gallery items, use Named Formulas where the value truly needs to stay live, and check the Power Apps Refresh function usage — refreshing a data source too often is a silent performance killer.

SharePoint and Dataverse Questions

Almost every mid-to-senior interview includes at least a few questions comparing these two data sources.

18. SharePoint list or Dataverse table — how do you decide which one to use?

Dataverse is a proper relational database with rich data types, real relationships, business rules, and row-level security, which makes it the right choice for complex, multi-table business apps. A SharePoint list is faster to spin up and fine for simpler apps or teams without Dataverse licensing. I break this decision down fully in Power Apps Dataverse vs SharePoint list.

19. What is a Dataverse Choice column and how is it different from a SharePoint Choice column?

Both store a fixed set of options, but Dataverse Choice columns (formerly called option sets) can be shared across multiple tables and environments, while a SharePoint Choice column lives only inside that one list. Filtering a Dataverse choice column also needs a slightly different formula pattern, which I cover in filtering a Dataverse Choice column.

20. How do you migrate a SharePoint list to Dataverse?

I map columns first, since data types don’t line up one-to-one, then use the built-in migration tooling or Power Automate to move records over in batches, and finally repoint the Canvas app’s data source and retest every formula that referenced SharePoint-specific behavior. The full process is in migrating a SharePoint Online list to Dataverse.

21. What is a Dataverse formula column?

A formula column calculates its value automatically from other columns in the same row, similar to a calculated column, but it recalculates in real time and can be used in views and reports. I use these instead of doing the same math repeatedly inside the Canvas app. See Dataverse formula column for a working example.

22. How do table relationships work in Dataverse?

Dataverse supports one-to-many and many-to-many relationships between tables, similar to foreign keys in SQL, which lets you build proper parent-child structures like Orders and Order Items. I’ve documented creating tables and relationships from scratch in creating a Dataverse table and creating a Dataverse table from a SharePoint list.

23. How do you deal with SharePoint’s 2,000-item delegation limit on a growing list?

I push as much filtering to the server as possible using delegable functions, add indexed columns for anything used in filters, and design the UI to force users to search or filter before loading a full list rather than showing everything by default. For date-based filtering, I lean on patterns like filtering a gallery by quarter and filtering a gallery by year, which stay delegable.

24. How do you create a folder in SharePoint directly from a Power Apps app?

I use the SharePoint connector’s SPCreateFolder action, usually triggered from a button after a record is created, so each record gets its own document folder automatically. The full steps are in creating a folder in SharePoint from Power Apps.

25. What is a Dataverse solution and why does it matter?

A solution is a container that packages your app, flows, tables, and other components together so they can be moved cleanly between environments — dev, test, and production. Without solutions, you end up manually recreating components in each environment, which is error-prone and impossible to version properly. More detail in Dataverse solution.

AI Builder Questions

AI Builder questions have become common as more clients ask for document automation inside their Power Apps projects.

26. What is AI Builder in Power Platform?

AI Builder is a set of pre-built and custom AI models — like form processing, object detection, and prediction — that you can plug directly into Power Apps and Power Automate without writing any machine learning code. It’s the easiest way to add “smart” features to a business app without bringing in a data science team.

27. What AI Builder capabilities have you actually worked with?

I’ve mostly used the Form Processor and Document Processing models to pull structured fields out of invoices, and I’ve worked with prediction models for simple yes/no classification tasks. A real example is detecting and extracting text inside Dataverse records, which I cover in detecting text in Dataverse using AI Builder.

28. How do you extract invoice data using AI Builder inside a Power Apps flow?

I train a Form Processor model on a handful of sample invoices, tag the fields I need — vendor name, invoice number, total — and then call that model from Power Automate whenever a new invoice lands in a SharePoint library. The complete build is in extracting invoice data from a PDF or image using Power Apps and extracting invoice details with AI Builder in Power Automate.

Pro Tip: In my experience, AI Builder’s accuracy really depends on training with realistic samples — messy scans, different vendor formats, low-resolution photos. Training on ten clean PDFs and expecting production-grade accuracy is the mistake I see most junior developers make.

29. What licensing considerations come with AI Builder?

AI Builder consumes credits, which are separate from standard Power Apps or Power Automate licensing, and every prediction or document processed draws from that pool. I always flag this to clients early, since heavy document processing volumes can burn through credits faster than expected.

30. How does AI Builder fit together with Power Automate and Power Apps in a real solution?

Typically, the Canvas app captures or displays the document, a Power Automate flow calls the AI Builder model to extract or classify data, and the result gets written back to Dataverse or SharePoint for the app to display. Keeping the AI logic in the flow, not the app, keeps the Canvas app fast and easy to maintain.

Copilot Studio Questions

Almost every recent interview I’ve heard about now includes at least two or three Copilot Studio questions.

31. What is Copilot Studio and how is it different from a traditional chatbot?

Copilot Studio is Microsoft’s low-code platform for building AI-powered conversational agents. Unlike a traditional rule-based chatbot that only follows scripted decision trees, Copilot Studio agents can use generative AI to understand natural language, pull from knowledge sources, and still fall back to structured Topics for precise, controlled flows. I cover the setup in creating an agent using Microsoft Copilot Studio.

32. What are Topics, Entities, and Variables in Copilot Studio?

A Topic is a defined conversation flow triggered by specific phrases, like “reset my password.” An Entity is a piece of information the agent extracts from user input, like a date or an employee ID. A Variable stores that captured information so it can be reused later in the conversation, such as passing an order number into a follow-up action.

33. How do you build a custom Topic in Copilot Studio?

I define trigger phrases the user might type, build the conversation flow with question nodes to capture entities, and add condition branches for different responses. The full walkthrough is in creating a custom Topic in Microsoft Copilot Studio.

34. How do event triggers work in Copilot Studio?

Event triggers let a Topic fire automatically based on a system event, like a conversation starting, rather than only reacting to what the user types. I’ve used these to show a welcome message or run a setup check the moment a chat session opens, detailed in adding event triggers in Microsoft Copilot Studio.

35. What are agent flows in Copilot Studio?

Agent flows are Power Automate-style flows built specifically to run inside a Copilot Studio agent’s conversation, letting the agent take real actions — create a record, send an approval, call an API — instead of just answering questions. I walk through building one in creating an agent flow in Copilot Studio.

36. How do you connect a SharePoint list to a Copilot Studio agent?

I add the SharePoint list either as a knowledge source, so the agent can answer questions from it directly, or wire it up through an agent flow to create and update list items conversationally. Both patterns are covered in using a SharePoint list as knowledge in Copilot Studio and creating a SharePoint list item using Copilot Studio.

37. How do you publish a Copilot Studio agent to a live website?

Once the agent is tested in the test canvas, I publish it and grab the embed code or use the Power Pages / custom website channel to drop it onto a live page. The full steps are in publishing an agent to a live website in Copilot Studio.

38. What’s the difference between Microsoft 365 Copilot and Copilot Studio?

Microsoft 365 Copilot is the AI assistant built into apps like Word, Teams, and Outlook to help with everyday productivity tasks. Copilot Studio is the platform you use to build your own custom agents from scratch for specific business processes. I break this distinction down in Microsoft 365 Copilot vs Copilot Studio.

Governance, Performance, and ALM Questions

For 3-5 years of experience, interviewers expect you to think beyond “does it work” and into “does it scale and stay maintainable.”

39. How do Standard and Premium connectors differ, and why does it matter for project planning?

Standard connectors are included in most Power Apps licenses, while Premium connectors — like SQL Server, Dataverse, or many third-party APIs — need a premium license per user or per app. I always check this during the design phase, because discovering a premium connector requirement after go-live is a budget conversation nobody enjoys. Full comparison here: Standard vs Premium connectors in Power Apps.

40. How do you troubleshoot a slow-loading Power Apps app?

I check OnStart first, since loading too much data upfront is the most common cause, then look for non-delegable filters, too many controls on one screen, and unnecessary image loading. Adding a loading indicator also improves perceived performance while the real fixes go in — see Power Apps loading spinner.

41. What is the Center of Excellence (CoE) Starter Kit and why do organizations use it?

The CoE Starter Kit is a set of Power Platform components that helps admins govern, monitor, and support citizen developers across an organization — tracking app usage, licensing, and adoption at scale. I’ve seen import issues with it firsthand, which I documented in the CoE Starter Kit import failure due to missing dependencies.

42. How do you secure a Canvas app before sharing it with a wider group?

I share the app with a Microsoft 365 group instead of individual users so access stays manageable, review the connections the app uses for over-permissioned service accounts, and check the tenant’s Data Loss Prevention (DLP) policies before publishing. Sharing steps are in sharing a Canvas app with a Microsoft 365 group in Power Apps.

43. What naming conventions do you follow for controls and variables?

I prefix controls by type — btn for buttons, gal for galleries, txt for text inputs — and prefix variables by scope, like gbl for global and loc for context variables. Consistent naming makes formulas far easier to read months later, or for another developer picking up your app. I go deeper on this in Power Apps naming conventions.

44. How do you approach testing before deploying an app to production?

I test with real data volumes, not just a handful of sample rows, check delegation warnings again at scale, and walk through the app as each different user role or security group to confirm permissions behave as expected. I also test on the actual device type end users will use — a form that looks fine on a laptop can break badly on a phone.

45. What are Environment variables in Power Platform and why use them?

Environment variables store configuration values — like a SharePoint site URL or an API endpoint — outside the app itself, so moving a solution from dev to production only means updating the variable’s value, not editing formulas inside every app and flow. This is one of the first things I set up on any multi-environment project.

Model-Driven Apps and Broader Platform Questions

46. What is a Model-driven app and how is it different from a Canvas app?

A Model-driven app is generated automatically from your Dataverse data model — tables, forms, views, and business rules — giving you a consistent, responsive UI with far less manual screen design. A Canvas app gives you full pixel-level control over layout but requires you to build every screen yourself. I compare both in detail in Model-driven apps in Power Apps.

47. What is Microsoft Dataverse in one sentence, and why does it matter for enterprise apps?

Dataverse is Microsoft’s cloud-based, secure business database that underpins Power Apps, Power Automate, Dynamics 365, and Copilot Studio, giving all of them a shared, governed data layer. For anything beyond a simple departmental app, I recommend clients build on Dataverse from day one. More background in What is Microsoft Dataverse.

48. How would you explain Power Apps’ advantage over traditional custom development to a stakeholder?

Low-code development in Power Apps lets you build and ship business apps in weeks instead of months, without a dedicated development team for every small internal tool, while still allowing custom code and connectors for complex needs. I lay out the tradeoffs honestly in Power Apps vs traditional development.

49. How do you decide whether a client project should be Canvas, Model-driven, or a hybrid?

I look at how structured the data already is — heavily relational data with many tables usually points to Model-driven, while a highly custom, visual, or mobile-first experience points to Canvas. For larger enterprise solutions, I often recommend a hybrid: Model-driven for back-office data management and Canvas embedded inside it for a tailored front-end experience.

50. What’s one mistake you’ve made on a Power Apps project that taught you something important?

I once built an app entirely against a SharePoint list because it was “quick to start,” only to hit delegation limits and performance issues six months later when the list grew past 5,000 items. Migrating to Dataverse mid-project cost far more time than planning for scale upfront would have. Now I always ask about expected data volume before choosing a data source, not after.

Tips to Keep in Mind Before Your Interview

• Practice explaining your reasoning, not just the answer. Interviewers care more about why you’d choose Patch over SubmitForm in a given scenario than whether you can recite the syntax.
• Know the current data source debate cold. SharePoint vs Dataverse questions come up in almost every interview at this experience level, so be ready to justify your choice with real tradeoffs.
• Don’t skip AI Builder and Copilot Studio. These used to be “nice to know” a couple of years ago — now they show up as core rounds, as the interview experience I reviewed for this article confirms.
• Have one or two real project stories ready. A specific example, like solving a delegation issue on a production app, lands far better than a generic textbook answer.
• Brush up on governance basics. Questions about DLP policies, sharing, and the CoE Starter Kit show you can be trusted with production apps, not just build demos.
• Test your formulas out loud before the interview. Practicing how you’d explain Patch(), Filter(), and Collect() in plain English helps you avoid freezing up when asked live.

Frequently Asked Questions

You may also like the following tutorials:

• Power Apps Interview Questions and Answers
• Power Apps Interview Questions and Answers for Experienced Developers
• Model-Driven Apps in Power Apps
• What is Microsoft Dataverse
• Power Apps vs Traditional Development

This list covers the questions I’ve personally seen come up most often for Power Apps roles at the 3-5 year mark, from Canvas app fundamentals through Dataverse, AI Builder, and Copilot Studio. The best preparation is still building a small real app yourself and walking through every design decision out loud, since that’s exactly what a good interviewer will ask you to do. Good luck with your interview.

The report already has clean data from Excel, SharePoint, or SQL Server. The missing piece is a way to tell a calculation exactly which rows matter. That is where Power BI DAX FILTER becomes useful.

This guide walks through how to use the FILTER function in a practical retail sales dashboard, including common patterns, measures, visuals, and mistakes to avoid.

What Is Power BI DAX FILTER?

FILTER is a DAX function that returns a table containing only the rows that meet a condition. DAX stands for Data Analysis Expressions, the formula language that powers calculations in Power BI.

Unlike a visual-level filter or a slicer, FILTER works inside a formula. It lets you define custom logic for a Measure, which is a calculation that changes based on the current filters in your report.

The syntax looks like this:

FILTER(<table>, <filter_expression>)

• <table> is the table that you want to examine.
• <filter_expression> is the condition that each row must satisfy.

For example, imagine a Sales table with these columns:

• Order Date
• Product
• Region
• Salesperson
• Amount
• Quantity

This formula returns sales rows where the order amount exceeds 1,000:

FILTER(
    Sales,
    Sales[Amount] > 1000
)

By itself, FILTER returns a table, not a single number. That is why you will usually use it inside another DAX function, especially CALCULATE.

For a wider introduction to DAX concepts before building more advanced formulas, read this guide on Power BI DAX.

Why Use Power BI DAX FILTER?

A standard report filter works well when every visual needs the same rule. However, real dashboards often need one visual to follow a special business rule while other visuals keep showing all data.

For example, a retail company may want these KPIs on one sales dashboard:

• Total sales from every completed order.
• Sales from the West region only.
• Revenue from orders above 1,000.
• Revenue from orders created in the last 30 days.
• Sales from products with a margin greater than 25 percent.

You could create separate pages or apply visual filters. But that approach becomes difficult to maintain when users need several calculations together in a single interactive report.

Power BI DAX FILTER gives each measure its own rule. Your total sales card can show all sales, while a second card shows only high-value sales. Both cards can still respond to the same Year, Region, and Product Slicers.

Pro Tip: I have found that measures with clear business names save a lot of support time later. Name a measure High Value Sales instead of Measure 7, and document the threshold in the formula or model description.

Build the Sales Data Model First

Before writing DAX, set up a clean Data model. In client projects, I usually start with a simple star schema. A star schema keeps one large transaction table in the center and connects it to smaller lookup tables.

For this example, use these tables:

• Sales: Fact table with one row per sales order line.
• Date: Calendar table with one row per date.
• Products: Product name, category, and brand.
• Customers: Customer name, segment, and city.
• Regions: Region and sales territory details.

The Sales table sits in the center. Create one-to-many relationships from the lookup tables to Sales:

• Date[Date] to Sales[Order Date]
• Products[Product ID] to Sales[Product ID]
• Customers[Customer ID] to Sales[Customer ID]
• Regions[Region ID] to Sales[Region ID]

Use a single filter direction from each lookup table to the Sales table. This design makes DAX measures easier to understand and helps prevent incorrect totals.

You can also learn how to work with relationships when unique values are unavailable in this guide about creating a relationship in Power BI without unique values.

Create and Mark a Date Table

A separate Date table gives your report a reliable calendar for monthly, quarterly, and yearly analysis. It also supports time-intelligence calculations.

In Power BI Desktop, select Modeling > New table, then enter:

Date =
CALENDAR(
    DATE(2023, 1, 1),
    DATE(2026, 12, 31)
)

Add supporting columns:

Year = YEAR('Date'[Date])

Month Number = MONTH('Date'[Date])

Month Name = FORMAT('Date'[Date], "MMMM")

Next, select the Date table, choose Table tools > Mark as date table, and select the Date column. Then sort Month Name by Month Number so months appear in calendar order instead of alphabetical order.

If you need a user-friendly date selection control, this article explains how to create a Power BI date slicer.

Create the Base Measure

Always create a base measure before adding complex filters. In this sales dashboard, the basic measure is total sales:

Total Sales =
SUM(Sales[Amount])

This Measure adds the values in Sales[Amount]. It automatically responds to filters from visuals, slicers, the report page, and related tables.

Add Total Sales to a Card visual. Then add a clustered column chart with Products[Category] on the X-axis and Total Sales on the Y-axis. Add a line chart with Date[Month Name] and Total Sales to show the sales trend.

A well-designed measure makes future formulas much shorter. Instead of repeating SUM(Sales[Amount]) in every formula, you reuse [Total Sales].

This is also why a Measure differs from a calculated column. A calculated column stores a value for every row during refresh, while a measure calculates results only when users view the report. See this detailed explanation of the difference between a calculated column and measure in Power BI.

Power BI DAX FILTER With CALCULATE

CALCULATE changes the filter context of a calculation. Filter context means the set of rows that Power BI considers when it calculates a measure.

The structure is:

CALCULATE(
    <expression>,
    <filter>
)

To calculate sales for orders above 1,000, create this measure:

High Value Sales =
CALCULATE(
    [Total Sales],
    FILTER(
        Sales,
        Sales[Amount] > 1000
    )
)

Here is what happens:

1. [Total Sales] tells Power BI what to calculate.
2. FILTER(Sales, Sales[Amount] > 1000) keeps only rows where the amount is greater than 1,000.
3. CALCULATE evaluates Total Sales using those filtered rows.

Add this measure to a second Card visual beside Total Sales. A manager can now compare overall revenue with revenue from high-value orders.

The formula remains interactive. If the manager selects the South region in a Slicer, both the card and the formula only consider South region sales. Then the FILTER condition further keeps orders above 1,000.

For additional examples with multiple conditions, review this guide on counting data with multiple filter conditions in Power BI DAX.

Filter Rows With Multiple Conditions in Power BI

You can combine several conditions with the && operator, which means “and.” Suppose your sales director wants revenue from high-value Technology orders:

High Value Technology Sales =
CALCULATE(
    [Total Sales],
    FILTER(
        Sales,
        Sales[Amount] > 1000 &&
        RELATED(Products[Category]) = "Technology"
    )
)

This formula checks each row in Sales. It keeps the row only when the amount exceeds 1,000 and the related product category equals Technology.

RELATED retrieves a value from a related lookup table. It works well here because Products has a relationship with Sales.

If your condition uses columns from only one table, a simpler Boolean filter often works:

West Region Sales =
CALCULATE(
    [Total Sales],
    Regions[Region Name] = "West"
)

Use the simpler filter when possible. Use FILTER when your logic needs row-by-row evaluation, involves a measure, uses more complex comparisons, or needs functions such as RELATED.

Filter Sales by Date in Power BI

Date-based filters are among the most common uses of Power BI DAX FILTER. A sales manager often asks, “How much did we sell in the last 30 days?” or “What did this year’s revenue look like?”

Create a measure for sales in the last 30 days:

Sales Last 30 Days =
CALCULATE(
    [Total Sales],
    FILTER(
        ALL('Date'[Date]),
        'Date'[Date] > TODAY() - 30 &&
        'Date'[Date] <= TODAY()
    )
)

ALL(‘Date'[Date]) removes the existing filter from the Date column before the formula applies its own 30-day date range. Without it, a Month slicer might limit the available dates and create unexpected results.

Then FILTER keeps dates from the past 30 days through today. Power BI sends that date filter through the relationship to the Sales table.

Use this measure in a card, and place it next to a card for monthly sales. It gives leaders a rolling view that does not reset when a new month begins.

If date logic does not behave as expected, start with this guide on fixing a Power BI DAX date filter that is not working. For other rolling-period examples, see how to filter last N days of data using Power BI DAX.

Compare Current Sales to Last Year in Power BI

A proper Date table also makes year-over-year comparisons simple:

Sales LY =
CALCULATE(
    [Total Sales],
    SAMEPERIODLASTYEAR('Date'[Date])
)

SAMEPERIODLASTYEAR shifts the current date selection back one year. If a user selects March 2026, the measure returns sales for March 2025.

Create a variance measure:

Sales Variance =
[Total Sales] - [Sales LY]

Create a percentage measure:

Sales Growth % =
DIVIDE(
    [Sales Variance],
    [Sales LY],
    0
)

Format Sales Growth % as a percentage. Add Total Sales, Sales LY, and Sales Growth % to cards. Then use conditional formatting to show positive growth in green and negative growth in red.

For a separate practical example, explore month-over-month change in Power BI.

Use FILTER to Ignore a Visual Selection

Sometimes a measure must keep one filter but ignore another. For example, a category bar chart should show each category’s sales as a percentage of the selected region total.

Start with this measure:

Category Sales % of Region =
DIVIDE(
    [Total Sales],
    CALCULATE(
        [Total Sales],
        ALL(Products[Category])
    ),
    0
)

ALL(Products[Category]) removes the category filter only. It does not remove filters for Region, Year, or Customer Segment. This makes the denominator the total sales for the current region and date selection.

Now consider a stricter example. Your sales team may need sales that ignore the Product slicer but still respect the Region slicer:

Sales Ignoring Product Selection =
CALCULATE(
    [Total Sales],
    REMOVEFILTERS(Products)
)

REMOVEFILTERS clearly states that you want to remove filters from a table or column. It often reads better than ALL when the goal is filter removal.

Choose these patterns carefully. Removing too many filters can produce a number that users cannot explain. Use a clear visual title such as “Share of Selected Region Sales” so people understand what the KPI represents.

For more examples, see this guide on how to remove filters in Power BI DAX.

Build the Interactive Report in Power BI

Now turn the measures into a useful sales dashboard. I usually create one executive summary page first, rather than placing every available visual on the canvas.

Use this layout:

• Add three Card visuals for Total Sales, High Value Sales, and Sales Growth %.
• Add a line chart showing Total Sales by month.
• Add a clustered bar chart showing Total Sales by product category.
• Add a matrix with Region, Salesperson, Total Sales, High Value Sales.
• Add slicers for Year, Region, Product Category, and Customer Segment.

Keep the cards at the top because managers often need answers within seconds. Use the line chart to show direction over time, then use the category chart and matrix to explain the reason behind the trend.

When the report looks correct, publish it to a Power BI Service workspace. A workspace is a shared online area where a team can manage reports, dashboards, datasets, and access.

Before sharing, test each slicer with your DAX measures. Select a single region, multiple categories, and a date range. Check whether the business result matches the intended definition.

Pro Tip: In my experience, a measure is only complete after someone tests it with unexpected slicer combinations. Most DAX issues come from filter context, not from spelling errors in the formula.

Key Points

• Use a star schema: Keep dimension tables such as Date, Products, and Regions separate from the Sales fact table. Clear relationships make filter flow predictable.
• Create base measures first: Reuse measures such as [Total Sales] inside other DAX measures. This keeps formulas shorter and easier to maintain.
• Avoid unnecessary FILTER calls: A direct filter inside CALCULATE usually performs better when the condition only compares a column to a fixed value.
• Check blank values: Blank dates, missing region IDs, and blank amounts can change results. Review data quality in Power Query before blaming the DAX formula.
• Use Row-Level Security carefully: Row-Level Security restricts data for specific users. Test DAX measures under every security role before publishing sensitive sales data.
• Make business rules visible: Include the threshold in a visual title or tooltip. Users should know whether “High Value” means orders above 1,000 or another amount.

Frequently Asked Questions

Power BI DAX FILTER lets you create focused, reliable measures for high-value orders, rolling sales periods, and custom KPI logic. Start with a clean data model and reusable base measures, then use CALCULATE and FILTER only where the business rule truly needs them. I hope you found this article helpful.

You may also like

• SELECTEDVALUE with Power BI DAX FILTER
• Filter blank values in Power BI
• Create a dropdown slicer in Power BI
• Set up Row-Level Security in Power BI
• Create a report in Power BI Desktop

I have seen this issue often when teams move from Excel reports to a proper Power BI sales dashboard. A clean month slicer gives users a familiar way to explore revenue, orders, profit, and KPIs without touching the underlying data.

This practical Power BI tutorial shows how to build a reliable Power BI date slicer by month, sort it correctly, connect it to visuals, and avoid common date-model mistakes.

Why Use a Power BI Date Slicer by Month?

A Slicer is a visual filter that lets report users choose values directly on the report canvas. When users select a month, Power BI filters connected visuals such as cards, bar charts, tables, and line charts.

For a retail sales dashboard, a monthly slicer helps a regional manager focus on one period without creating separate report pages. They can select January to review the new-year campaign, then switch to December to check holiday performance.

A month slicer works best when users ask questions like these:

• What were total sales in April?
• Which product category performed best last month?
• Did the South region meet its monthly target?
• How do current-month sales compare with the same month last year?
• Which month had the highest profit?

The most important point is this: do not build the slicer directly from a random date column if the report will grow. Create a dedicated Date table first. A Date table is a separate table that contains one row per calendar date and supports consistent time-based analysis.

Power BI Date Slicer by Month: Example Setup

For this guide, I will use a sales dashboard for a mid-sized retail company. The company stores transaction data in an Excel file, but the same approach works with SharePoint Online, SQL Server, Dataverse, and other sources.

The main table is called Sales and includes these columns:

Start by loading the table into Power BI Desktop.

1. Open Power BI Desktop.
2. Select Get data from the Home ribbon.
3. Choose Excel workbook if your data comes from an Excel file.
4. Select the worksheet or table that contains the sales data.
5. Click Load.

Before you add a slicer, check the OrderDate column. Select the column in Data view, open Column tools, and confirm that its data type is Date or Date/Time.

A date stored as text creates many problems. Power BI may display it in the wrong format, sort it incorrectly, or fail to calculate year-over-year measures.

Create a Proper Date Table in Power BI

A dedicated Date table gives every report visual a single, consistent calendar. It also lets you add useful fields such as Month Name, Month Number, Quarter, and Year-Month.

In Modeling, select New table and enter this DAX formula:

Date =
ADDCOLUMNS(
    CALENDAR(
        MIN(Sales[OrderDate]),
        MAX(Sales[OrderDate])
    ),
    "Year", YEAR([Date]),
    "Month Number", MONTH([Date]),
    "Month Name", FORMAT([Date], "MMMM"),
    "Month Short Name", FORMAT([Date], "MMM"),
    "Year Month", FORMAT([Date], "YYYY-MM"),
    "Year Month Sort", YEAR([Date]) * 100 + MONTH([Date]),
    "Quarter", "Q" & FORMAT([Date], "Q")
)

This formula creates one date row for every day between the earliest and latest order dates in the Sales table.

The added columns make the table useful for reporting:

• Year returns the calendar year, such as 2026.
• Month Number returns values from 1 to 12.
• Month Name returns full names such as January and February.
• Month Short Name returns shorter labels such as Jan and Feb.
• Year Month creates labels such as 2026-03.
• Year Month Sort creates a numeric sorting value such as 202603.
• Quarter creates labels such as Q1 and Q2.

Next, mark it as a Date table.

1. Select the Date table in the Fields pane.
2. Open Table tools.
3. Select Mark as date table.
4. Choose the Date[Date] column.
5. Click OK.

This tells Power BI that the table is your official reporting calendar. It matters when you use time-intelligence DAX measures such as year-to-date sales or same-period-last-year sales.

Pro Tip: I always create a Date table even for small reports. A report may start with one chart and one slicer, but it often grows into a multi-page dashboard. A clean date dimension prevents rework later.

Create the Relationship in Power BI

A relationship connects tables in the Data model. In this example, the Date table must filter the Sales table through the order date.

1. Open Model view from the left navigation.
2. Drag Date[Date] onto Sales[OrderDate].
3. Confirm that the relationship has these settings:
   • Cardinality: One to many (1:)
   • Cross-filter direction: Single
   • Relationship active: Enabled
4. Select OK.

The Date table should sit on the “one” side because every date appears only once. The Sales table belongs on the “many” side because multiple sales may happen on the same day.

This design follows a simple star schema. A star schema places transaction data in a central fact table, such as Sales, and connects it to lookup tables, such as Date, Product, Customer, and Region. It makes filters predictable and simplifies DAX measures.

Sort Month Names Correctly in Power BI

If you add Month Name to a slicer now, Power BI may sort the values alphabetically:

• April
• August
• December
• February

That order looks wrong because it ignores the calendar sequence. Fix this by sorting the month names with the numeric month field.

1. Select the Month Name column in the Date table.
2. Open Column tools.
3. Select Sort by column.
4. Choose Month Number.

Now Power BI will show January through December in the correct order.

However, a Month Name slicer alone has one important limitation. If your report contains data for multiple years, selecting “March” combines March 2025, March 2026, and every other March in your model.

That may be useful for seasonal analysis, but it is usually not what a sales manager expects. For normal monthly reporting, use Year Month instead.

Select Date[Year Month], then choose Sort by column and select Date[Year Month Sort]. This creates a slicer with values such as:

• 2025-11
• 2025-12
• 2026-01
• 2026-02
• 2026-03

This format clearly identifies the month and year.

Add the Power BI Date Slicer by Month

Now add the interactive filter to the sales dashboard.

1. Open Report view.
2. Select a blank part of the report canvas.
3. Choose the Slicer visual from the Visualizations pane.
4. Drag Date[Year Month] into the slicer Field well.
5. Resize the slicer so users can easily read each month.
6. Open the Format pane and set the slicer style to Dropdown or List.

Use a Dropdown slicer when you have several years of data and need to save canvas space. Use a List slicer when users should quickly compare and click a few recent months.

For a compact executive dashboard, I usually use a dropdown slicer near the top-left corner. For an analyst page, I prefer a list slicer because the visible choices make exploration faster.

You can also configure the selection behavior:

1. Select the slicer.
2. Open Format visual.
3. Expand Slicer settings.
4. Turn on Single select if users should view only one month at a time.
5. Turn off Single select if users should compare several months.

Turn on Select all only when users genuinely need it. Otherwise, it adds an unnecessary option and can confuse non-technical report users.

Build Visuals That Respond to the Slicer

A slicer becomes valuable when it filters useful visuals. Create a few basic DAX measures before building the report.

Select the Sales table, choose New measure, and add this formula:

Total Sales =
SUM(Sales[SalesAmount])

This Measure adds all sales amounts in the current filter context. Filter context means Power BI automatically calculates the result based on active filters, including the selected month, region, product, or page filter.

Create an order-count measure:

Total Orders =
DISTINCTCOUNT(Sales[OrderID])

This measure counts unique order IDs. It is more reliable than a basic row count when your source may contain multiple rows for one order.

Now create a prior-year measure:

Sales LY =
CALCULATE(
    [Total Sales],
    SAMEPERIODLASTYEAR(Date[Date])
)

The CALCULATE function changes the filter context for a measure. Here, it tells Power BI to calculate Total Sales for the same selected dates one year earlier.

Add a final measure for year-over-year change:

Sales YoY % =
DIVIDE(
    [Total Sales] - [Sales LY],
    [Sales LY]
)

Format Sales YoY % as a percentage from the Measure tools ribbon.

Build these visuals on the report page:

• A Card visual for Total Sales.
• A second Card for Total Orders.
• A third Card for Sales YoY %.
• A Clustered column chart with ProductCategory on the X-axis and Total Sales on the Y-axis.
• A Line chart with Date[Date] on the X-axis and Total Sales on the Y-axis.
• A Bar chart with Region on the Y-axis and Total Sales on the X-axis.
• The Year Month slicer at the top of the page.

When a user picks 2026-03, every visual should update to show March 2026 data. This is the core value of an interactive report.

For more advanced conditional filtering, you can also use DAX FILTER with SELECTEDVALUE in Power BI. It helps when a measure needs to react differently based on one selected slicer value.

Use Month and Year Slicers Separately

Some teams prefer two slicers: one for Year and another for Month Name. This design works well when users want to compare the same month across selected years.

Add one Slicer visual with Date[Year] and another with Date[Month Name]. Because both fields come from the same Date table, they work together automatically.

For example, a user can select 2026 from the Year slicer and March from the Month slicer. The report then shows only March 2026.

This design feels familiar to people who work with Excel pivot tables. However, it needs clear labeling. A user may select a month but forget to select a year, which combines the same month across all years.

Pro Tip: In client dashboards, I use separate Year and Month slicers only when the business users ask for them. For most executive reports, one Year Month slicer causes fewer mistakes and answers the reporting question faster.

Format the Slicer for Real Users

A slicer should look like part of the dashboard, not a technical control added at the end.

Use these formatting choices:

• Set the slicer title to Select Reporting Month.
• Use the same font family as your KPI cards and charts.
• Keep the slicer background subtle and easy to read.
• Avoid very small text, especially for reports viewed in the Power BI Service.
• Place the slicer in the same location across report pages.
• Use clear labels such as “Reporting Month” instead of “Year Month.”

You can control whether the slicer affects every visual. Select the slicer, open the Format ribbon, and choose Edit interactions. Each visual displays icons that let you choose filtering, highlighting, or no interaction.

For example, you might allow the month slicer to filter all sales visuals but not a static instruction card.

Publish and Share the Monthly Report

After testing the report in Power BI Desktop, publish it to the Power BI Service.

1. Save the PBIX file with a meaningful name, such as Retail Sales Dashboard.
2. Select Publish from the Home ribbon.
3. Sign in with your organizational account.
4. Choose a workspace.

A workspace is a shared area in Power BI Service where teams manage reports, dashboards, datasets, permissions, and apps. Create separate workspaces for development, testing, and production if several people build reports.

After publishing, open the report in the Power BI Service and test the slicer again. Check the report in a browser and on a smaller screen. A slicer that looks perfect in Desktop may need resizing for users on laptops.

If users need data outside the report, review how to export Power BI data to Excel without breaking reporting governance.

You can also embed a published report in a customer-facing portal. For example, this guide on displaying Power BI reports in Power Pages is useful when a secure external portal needs interactive reporting.

Useful Tips

• Use a dedicated Date table: Do not rely on scattered date columns in multiple fact tables. A single calendar keeps filtering and time intelligence consistent.
• Sort month labels by numbers: Month names sort alphabetically unless you use Sort by column with Month Number.
• Avoid Month Name by itself: “January” without a year combines data from every January. Use Year Month for regular monthly reporting.
• Keep relationships simple: Use a one-to-many relationship from Date to Sales. Avoid many-to-many date relationships unless you fully understand the business scenario.
• Use measures for KPIs: Build Total Sales, Total Orders, and growth metrics as Measures, not calculated columns. Measures respond to slicers and use less model storage.
• Secure sensitive data: Use Row-Level Security when regional managers should only see their own territory’s sales. A slicer controls analysis; it does not provide security.

Frequently Asked Questions

A Power BI date slicer by month becomes reliable when it uses a proper Date table, a clean relationship, and correctly sorted Year Month labels. Build the slicer around Year Month for daily business reporting, then use measures to let every KPI and visual respond to the selected period. I hope you found this article helpful.

You May Also Like

• Power BI DAX GROUPBY with FILTER
• Power BI DAX FILTER
• Power BI Free vs Pro vs Premium
• Add a Dropdown Slicer in Power BI
• Power BI Date Slicer Only Shows Dates With Data
• Sort Slicer By Measure in Power BI

That’s exactly what this post is about. I’m putting together a growing collection of PnP PowerShell scripts that any SharePoint developer can pick up and use directly on their own SharePoint site. You just swap out the site URL, client ID, tenant name, or a couple of parameters, and the script does the rest. No rewriting from scratch, no guessing at cmdlet syntax.

A lot of people I talk to don’t have this kind of script library handy. They end up rewriting the same Connect-PnPOnline, New-PnPList, or Add-PnPField commands from scratch every time, or worse, doing it manually through the browser. So instead of writing one script and moving on, I’m building this into a living reference: creating sites, creating lists and libraries, adding columns of different types, and even seeding sample data so you can test your setup without typing in dummy rows by hand.

Every script here is ready to copy, paste, and run directly on your SharePoint site. Just plug in your own site URL and client ID, and you’re good to go. I’ll keep adding new scripts to this post as I use them in real projects, so bookmark it.

PnP PowerShell Script: Create SharePoint List with Multi-Select Choice Column

As a developer, if you want to create a SharePoint list with a multi-select choice column, then use the script below:

<#
=====================================================================
 Script   : Create-CandidateList.ps1
 Purpose  : Creates a SharePoint Online list named "Candidates" with a
            multi-select Choice column (JobLocation) and populates it
            with sample candidate records.
 Module   : PnP.PowerShell
=====================================================================
#>

# ----------------------------[ CONNECTION ]---------------------------
$ClientID = "655a839c-8659-bbbbbbb-cccc-bbbbbbbbb"
$SiteUrl  = "https://tsinfotechnologies.sharepoint.com/sites/SPGuides"

Connect-PnPOnline -Url $SiteUrl -ClientId $ClientID -Interactive

# ----------------------------[ VARIABLES ]----------------------------
$ListName = "Candidates"

$Choices = @(
    "Texas",
    "Washington",
    "England",
    "Victoria",
    "Scotland",
    "Ireland",
    "California",
    "Florida",
    "Brasilia",
    "Ontario"
)

# --------------------------[ CREATE THE LIST ]------------------------
$List = Get-PnPList -Identity $ListName -ErrorAction SilentlyContinue

if ($null -eq $List) {
    Write-Host "Creating list '$ListName'..." -ForegroundColor Cyan
    $List = New-PnPList -Title $ListName -Template GenericList -OnQuickLaunch
    Write-Host "List '$ListName' created successfully." -ForegroundColor Green
}
else {
    Write-Host "List '$ListName' already exists. Skipping creation." -ForegroundColor Yellow
}

# ------------------[ RENAME TITLE COLUMN (OPTIONAL) ]-----------------
# The default 'Title' column will hold the candidate name.
Set-PnPField -List $ListName -Identity "Title" -Values @{ Title = "Candidate Name" }

# --------------[ CREATE MULTI-CHOICE COLUMN: JobLocation ]------------
$Field = Get-PnPField -List $ListName -Identity "JobLocation" -ErrorAction SilentlyContinue

if ($null -eq $Field) {
    Write-Host "Creating 'JobLocation' multi-choice column..." -ForegroundColor Cyan

    Add-PnPField -List $ListName `
                 -DisplayName "JobLocation" `
                 -InternalName "JobLocation" `
                 -Type MultiChoice `
                 -Choices $Choices `
                 -AddToDefaultView

    Write-Host "'JobLocation' column created with multiple selections enabled." -ForegroundColor Green
}
else {
    Write-Host "'JobLocation' column already exists. Skipping creation." -ForegroundColor Yellow
}

# ----------------------[ SAMPLE CANDIDATE RECORDS ]-------------------
$Candidates = @(
    @{ Name = "Michael Johnson";   Locations = @("Texas", "California") },
    @{ Name = "Jennifer Martinez"; Locations = @("Florida", "Ontario", "Texas") },
    @{ Name = "Christopher Davis"; Locations = @("Washington") },
    @{ Name = "Ashley Wilson";     Locations = @("England", "Scotland", "Ireland") },
    @{ Name = "Matthew Anderson";  Locations = @("Victoria", "Ontario") },
    @{ Name = "Emily Thompson";    Locations = @("California", "Washington", "Florida") },
    @{ Name = "Daniel Rodriguez";  Locations = @("Brasilia", "Texas") },
    @{ Name = "Sarah Brown";       Locations = @("Ireland", "England") },
    @{ Name = "Joshua Miller";     Locations = @("Ontario", "Victoria", "Scotland") },
    @{ Name = "Amanda Garcia";     Locations = @("Florida") },
    @{ Name = "Andrew Taylor";     Locations = @("Texas", "Washington", "California") },
    @{ Name = "Jessica White";     Locations = @("Scotland", "Brasilia") },
    @{ Name = "Ryan Harris";       Locations = @("California") },
    @{ Name = "Megan Clark";       Locations = @("England", "Victoria") },
    @{ Name = "Brandon Lewis";     Locations = @("Ontario", "Florida", "Ireland") }
)

Write-Host "`nAdding candidate records..." -ForegroundColor Cyan

foreach ($Candidate in $Candidates) {
    try {
        Add-PnPListItem -List $ListName -Values @{
            "Title"       = $Candidate.Name
            "JobLocation" = $Candidate.Locations
        } | Out-Null

        Write-Host ("  [OK] {0}  ->  {1}" -f $Candidate.Name, ($Candidate.Locations -join ", ")) -ForegroundColor Green
    }
    catch {
        Write-Host ("  [FAIL] {0} : {1}" -f $Candidate.Name, $_.Exception.Message) -ForegroundColor Red
    }
}

Write-Host "`nAll done! '$ListName' list is ready with $($Candidates.Count) records." -ForegroundColor Cyan

# -------------------------[ DISCONNECT ]------------------------------
Disconnect-PnPOnline

It will create a SharePoint list like in the screenshot below:

PnP PowerShell Script: Create a SharePoint List (With Person or Group (single & multiple) column) and Add 10 Records

Below is a single, self-contained script. It connects, creates the Project Tracker list, adds the Person and Person-multi columns, resolves the five users, and then inserts 10 items with randomly assigned managers and members.

One important technical note: Add-PnPField -Type User creates a single person column, but there is no UserMulti value in the FieldType enum. To get a multiple person column you must create it from field XML with Mult="TRUE". The script handles this correctly.

<#
    Creates the "Projects Tracker" list in SharePoint Online and
    populates it with 10 sample records using PnP PowerShell.

    Columns:
        Title           (Text)
        ProjectManager  (Person or Group - single)
        ProjectMembers  (Person or Group - multiple)
#>

#region Configuration ---------------------------------------------------------

$ClientID = "655a839c-8659-3322-3333-44444444444444"
$SiteUrl  = "https://tsinfotechnologies.sharepoint.com/sites/SPGuides"
$ListName = "Projects Tracker"

$UserEmails = @(
    "user1@tsinfotechnologies.onmicrosoft.com",
    "user2@tsinfotechnologies.onmicrosoft.com",
    "bijay@tsinfotechnologies.onmicrosoft.com",
    "preeti@tsinfotechnologies.onmicrosoft.com",
    "asit@tsinfotechnologies.onmicrosoft.com"
)

$ProjectTitles = @(
    "Website Redesign",
    "SharePoint Migration",
    "Power Automate Rollout",
    "Intranet Governance Review",
    "Teams Adoption Program",
    "Document Retention Policy",
    "Power BI Reporting Hub",
    "Security Baseline Audit",
    "Customer Portal Upgrade",
    "Knowledge Base Cleanup"
)

$ErrorActionPreference = "Stop"

#endregion

#region Connect ---------------------------------------------------------------

Write-Host "`nConnecting to $SiteUrl ..." -ForegroundColor Cyan

Connect-PnPOnline -Url $SiteUrl -ClientId $ClientID -Interactive

Write-Host "Connected." -ForegroundColor Green

#endregion

#region Create the list -------------------------------------------------------

Write-Host "`nChecking for the '$ListName' list ..." -ForegroundColor Cyan

$List = Get-PnPList -Identity $ListName -ErrorAction SilentlyContinue

if ($null -eq $List) {

    $List = New-PnPList `
        -Title $ListName `
        -Template GenericList `
        -OnQuickLaunch

    Write-Host "List '$ListName' created." -ForegroundColor Green
}
else {
    Write-Host "List '$ListName' already exists. Reusing it." -ForegroundColor Yellow
}

#endregion

#region Add the Person columns ------------------------------------------------

# --- ProjectManager : single person ---------------------------------------
$ManagerField = Get-PnPField `
    -List $ListName `
    -Identity "ProjectManager" `
    -ErrorAction SilentlyContinue

if ($null -eq $ManagerField) {

    Add-PnPField `
        -List $ListName `
        -DisplayName "Project Manager" `
        -InternalName "ProjectManager" `
        -Type User `
        -AddToDefaultView | Out-Null

    Write-Host "Column 'Project Manager' created." -ForegroundColor Green
}
else {
    Write-Host "Column 'Project Manager' already exists." -ForegroundColor Yellow
}

# --- ProjectMembers : multiple people -------------------------------------
# There is no 'UserMulti' value in the FieldType enum, so this column
# must be created from field XML using Mult="TRUE".

$MembersField = Get-PnPField `
    -List $ListName `
    -Identity "ProjectMembers" `
    -ErrorAction SilentlyContinue

if ($null -eq $MembersField) {

    $MembersFieldXml = @"
<Field Type="UserMulti"
       DisplayName="Project Members"
       Name="ProjectMembers"
       StaticName="ProjectMembers"
       List="UserInfo"
       ShowField="ImnName"
       UserSelectionMode="PeopleOnly"
       UserSelectionScope="0"
       Mult="TRUE"
       Required="FALSE" />
"@

    Add-PnPFieldFromXml `
        -List $ListName `
        -FieldXml $MembersFieldXml | Out-Null

    Write-Host "Column 'Project Members' created." -ForegroundColor Green

    # Add it to the default view
    $DefaultView = Get-PnPView -List $ListName | Where-Object { $_.DefaultView }

    if ($null -ne $DefaultView) {
        $ViewFields = @($DefaultView.ViewFields)

        if ($ViewFields -notcontains "ProjectMembers") {
            $DefaultView.ViewFields.Add("ProjectMembers")
            $DefaultView.Update()
            Invoke-PnPQuery
        }
    }
}
else {
    Write-Host "Column 'Project Members' already exists." -ForegroundColor Yellow
}

#endregion

#region Confirm the schema ----------------------------------------------------

Write-Host "`nList schema:" -ForegroundColor Cyan

Get-PnPField -List $ListName |
    Where-Object { $_.InternalName -in @("Title", "ProjectManager", "ProjectMembers") } |
    Select-Object Title, InternalName, TypeAsString |
    Format-Table -AutoSize

#endregion

#region Resolve the users -----------------------------------------------------

Write-Host "Resolving users ..." -ForegroundColor Cyan

$ResolvedUsers = @(
    foreach ($Email in $UserEmails) {
        try {
            New-PnPUser -LoginName $Email -ErrorAction Stop
        }
        catch {
            Write-Warning "Could not resolve '$Email'. $($_.Exception.Message)"
        }
    }
)

if ($ResolvedUsers.Count -eq 0) {
    throw "No users could be resolved. Cannot continue."
}

Write-Host "Resolved $($ResolvedUsers.Count) of $($UserEmails.Count) users." -ForegroundColor Green

$ResolvedUsers |
    Select-Object Id, Title, Email, LoginName |
    Format-Table -AutoSize

#endregion

#region Add 10 records --------------------------------------------------------

Write-Host "Adding 10 list items ..." -ForegroundColor Cyan

$Created = @()

for ($i = 0; $i -lt 10; $i++) {

    $Title = $ProjectTitles[$i]

    # Random project manager
    $Manager = Get-Random -InputObject $ResolvedUsers

    # Random 2 to 3 members (must be an array, never a delimited string)
    $MemberCount = Get-Random -Minimum 2 -Maximum ([Math]::Min(4, $ResolvedUsers.Count + 1))

    $Members = @(
        $ResolvedUsers |
            Get-Random -Count $MemberCount |
            ForEach-Object { $_.LoginName }
    )

    try {
        $NewItem = Add-PnPListItem `
            -List $ListName `
            -Values @{
                Title          = $Title
                ProjectManager = $Manager.LoginName
                ProjectMembers = $Members
            } `
            -ErrorAction Stop

        $Created += [pscustomobject]@{
            Id      = $NewItem.Id
            Title   = $Title
            Manager = $Manager.Title
            Members = $MemberCount
        }

        Write-Host ("  [{0,2}] {1,-32} PM: {2}" -f $NewItem.Id, $Title, $Manager.Title) `
            -ForegroundColor Green
    }
    catch {
        Write-Warning "Failed to create '$Title'. $($_.Exception.Message)"
    }
}

#endregion

#region Summary ---------------------------------------------------------------

Write-Host "`n$($Created.Count) of 10 items created successfully.`n" -ForegroundColor Cyan

$Created | Format-Table -AutoSize

Write-Host "Verifying from SharePoint ...`n" -ForegroundColor Cyan

Get-PnPListItem -List $ListName -Fields "Title", "ProjectManager", "ProjectMembers" |
    ForEach-Object {
        $Manager = $_["ProjectManager"]
        $Members = @($_["ProjectMembers"])

        [pscustomobject]@{
            Id      = $_.Id
            Title   = $_["Title"]
            Manager = if ($Manager) { $Manager.LookupValue } else { "" }
            Members = ($Members | ForEach-Object { $_.LookupValue }) -join "; "
        }
    } |
    Format-Table -AutoSize -Wrap

Write-Host "Done. View the list at:" -ForegroundColor Green
Write-Host "$SiteUrl/Lists/$($ListName -replace ' ','')`n"

Disconnect-PnPOnline

#endregion

Once you will execute the above script, it will create a SharePoint Online list like the below:

PnP PowerShell Script: Create a Leave Request List in SharePoint Online

The script will create a new SharePoint list called “Leave Requests” and add the following columns:

• EmployeeName – Person or Group field
• LeaveType – Choice field (common leave categories, edit as needed)
• StartDate / EndDate – Date and Time fields
• Reason – Multiple lines of text (Note type)
• Status – Choice field (Pending, Approved, Rejected)

The Title column is included automatically since every SharePoint list has it by default.

The script will also check if the list already exists in the SharePoint site.

$ClientID = "655a839c-8659-4229-44455-44444444444444"
$SiteUrl  = "https://tsinfotechnologies.sharepoint.com/sites/SPGuides"
$ListName = "Leave Requests"

Connect-PnPOnline -Url $SiteUrl -ClientId $ClientID -Interactive

$list = Get-PnPList -Identity $ListName -ErrorAction SilentlyContinue

if ($list) {
    Write-Host "List '$ListName' already exists. Skipping creation." -ForegroundColor Yellow
}
else {
    New-PnPList -Title $ListName -Template GenericList -OnQuickLaunch

    Add-PnPField -List $ListName -DisplayName "EmployeeName" -InternalName "EmployeeName" -Type User
    Add-PnPField -List $ListName -DisplayName "LeaveType" -InternalName "LeaveType" -Type Choice -Choices "Casual Leave","Sick Leave","Earned Leave","Maternity Leave","Paternity Leave"
    Add-PnPField -List $ListName -DisplayName "StartDate" -InternalName "StartDate" -Type DateTime
    Add-PnPField -List $ListName -DisplayName "EndDate" -InternalName "EndDate" -Type DateTime
    Add-PnPField -List $ListName -DisplayName "Reason" -InternalName "Reason" -Type Note
    Add-PnPField -List $ListName -DisplayName "Status" -InternalName "Status" -Type Choice -Choices "Pending","Approved","Rejected"

    Write-Host "List '$ListName' created successfully with all columns." -ForegroundColor Green
}

Once the SharePoint list is created, you can also add items to it using the following script.

This is how the script will work:

• Loops 5 times, each time picking a random email from $UserEmails, a random LeaveType, and a random Status using Get-Random.
• EmployeeName (a Person field) accepts the email string directly in Add-PnPListItem — PnP resolves it to the correct user internally, so no separate lookup call is strictly needed.
• StartDate is staggered by $i * 2 days from today, and EndDate is 2 days after that, so each item has a distinct, valid date range.
• Reason is a simple auto-generated string tied to the leave type, and Title is set as "Leave Request 1" through "Leave Request 5".

$ClientID = "655a839c-8659-4229-9993-444444444444444444"
$SiteUrl  = "https://tsinfotechnologies.sharepoint.com/sites/SPGuides"
$ListName = "Leave Requests"

$UserEmails = @(
    "user1@tsinfotechnologies.onmicrosoft.com",
    "user2@tsinfotechnologies.onmicrosoft.com",
    "bijay@tsinfotechnologies.onmicrosoft.com",
    "preeti@tsinfotechnologies.onmicrosoft.com",
    "asit@tsinfotechnologies.onmicrosoft.com"
)

$LeaveTypes = @("Casual Leave","Sick Leave","Earned Leave","Maternity Leave","Paternity Leave")
$StatusList = @("Pending","Approved","Rejected")

Connect-PnPOnline -Url $SiteUrl -ClientId $ClientID -Interactive

for ($i = 1; $i -le 5; $i++) {
    $email = Get-Random -InputObject $UserEmails
    $leaveType = Get-Random -InputObject $LeaveTypes
    $status = Get-Random -InputObject $StatusList
    $startDate = (Get-Date).AddDays($i * 2)
    $endDate = $startDate.AddDays(2)

    $user = Resolve-PnPUpn -Email $email -ErrorAction SilentlyContinue
    $userField = $email

    Add-PnPListItem -List $ListName -Values @{
        "Title"        = "Leave Request $i"
        "EmployeeName" = $userField
        "LeaveType"    = $leaveType
        "StartDate"    = $startDate
        "EndDate"      = $endDate
        "Reason"       = "Sample reason for $leaveType"
        "Status"       = $status
    }

    Write-Host "Item $i added for $email" -ForegroundColor Green
}

To add more items to the SharePoint list, change the value in the for loop.

Conclusion

That’s the script collection so far. Each one is built the same way: connect once, plug in your site URL and client ID, and run it directly on your SharePoint site. No extra setup, no digging through documentation halfway through your workday.

I’ll keep expanding this post as I come across more scenarios worth automating, so if there’s a specific SharePoint setup task you keep repeating manually, drop it in the comments, and I’ll add a script for it. Bookmark this page since it’s going to keep growing.

You may also like the following tutorials:

• Download All Files from a SharePoint Document Library Using PnP PowerShell
• Get SharePoint Folder Permissions Using PnP PowerShell
• Add More Than 5000 Items to a SharePoint Online List Using PnP PowerShell

You select the files, click Download, SharePoint starts zipping them, and then… it fails. Or it silently skips files. Or it hits the 250 MB / 10,000 file limit and gives up.

There’s a much better way – PnP PowerShell.

In this tutorial, I will show you how to download all documents from a SharePoint Online document library using PnP PowerShell, along with a lot of practical variations that people actually need in real projects – such as downloading only PDF files, downloading only files larger than 5 MB, downloading files from a specific folder, downloading files older than 30 days, and more.

Everything here is copy-paste ready. You only need to change a few variables at the top of each script.

Let’s get started.

What You Need Before You Start (Prerequisites)

Before running any script in this guide, make sure you have the following ready.

1. PowerShell 7 (recommended)

PnP PowerShell (version 2.x and above) requires PowerShell 7. Windows PowerShell 5.1 works only with the older, deprecated SharePointPnPPowerShellOnline module, which I do not recommend for new work.

To check your version, run:

$PSVersionTable.PSVersion

If you see 5.1, install PowerShell 7 first.

2. The PnP.PowerShell module

Install it with this command:

Install-Module -Name PnP.PowerShell -Scope CurrentUser -Force

To confirm it installed correctly:

Get-Module PnP.PowerShell -ListAvailable | Select-Object Name, Version

3. Permissions on the SharePoint site

You need at least Read access to the document library you want to download from. If you’re a Site Owner or SharePoint Administrator, you’re good.

4. An Entra ID (Azure AD) app registration

This is the part that trips up most beginners in PnP PowerShell v2 and v3. The old multi-tenant PnP app no longer works, so you must register your own app once per tenant.

Run this one-time command (you need to be a Global Administrator or Application Administrator):

Register-PnPEntraIDAppForInteractiveLogin -ApplicationName "PnP Rocks" -Tenant contoso.onmicrosoft.com -Interactive

Copy the Client ID that gets returned. You will use it in every connection command below.

Note: If your tenant already has a registered PnP app, ask your admin for the Client ID instead of creating a new one.

5. Connect to Your SharePoint Site

Every script in this tutorial starts with a connection. The most common method is interactive login (a browser window pops up, and you sign in normally).

$SiteURL  = "https://contoso.sharepoint.com/sites/Finance"
$ClientId = "11111111-2222-3333-4444-555555555555"

Connect-PnPOnline -Url $SiteURL -Interactive -ClientId $ClientId

To verify the connection worked:

Get-PnPWeb | Select-Object Title, Url

If you see your site title, you’re connected.

Running it unattended? If you plan to schedule the script (Task Scheduler or Azure Automation), use certificate-based app-only authentication instead:

Connect-PnPOnline -Url $SiteURL `
    -ClientId "11111111-2222-3333-4444-555555555555" `
    -Tenant "contoso.onmicrosoft.com" `
    -CertificatePath "C:\Certs\PnPCert.pfx" `
    -CertificatePassword (ConvertTo-SecureString -String "YourPfxPassword" -AsPlainText -Force)

App-only auth needs the Sites.Read.All (or Sites.FullControl.All) Graph/SharePoint API permission granted with admin consent.

6. Find the Correct Library Name and URL

Before downloading, confirm the exact name of your document library. Display names and internal URLs are often different (for example, a library shown as “Project Files” may have the URL /ProjectFiles).

Run this to list every document library on the site:

Get-PnPList | Where-Object { $_.BaseTemplate -eq 101 } |
    Select-Object Title, DefaultViewUrl, ItemCount

Make a note of the Title and the folder part of the DefaultViewUrl. You’ll need these next.

Check out Get SharePoint Document Library Size Using PnP PowerShell

Download All Files from a SharePoint Document Library

This is the core script. It downloads every file from the SharePoint document library, including all files inside subfolders, and recreates the exact same folder structure on your local drive.

# ---------- CONFIGURATION ----------
$SiteURL      = "https://contoso.sharepoint.com/sites/Finance"
$ClientId     = "11111111-2222-3333-4444-555555555555"
$LibraryName  = "Documents"
$DownloadPath = "C:\SPDownloads\Finance"
# -----------------------------------

Connect-PnPOnline -Url $SiteURL -Interactive -ClientId $ClientId

# Make sure the destination folder exists
if (-not (Test-Path $DownloadPath)) {
    New-Item -Path $DownloadPath -ItemType Directory -Force | Out-Null
}

# Get the library and its server-relative URL
$List       = Get-PnPList -Identity $LibraryName -Includes RootFolder
$LibraryUrl = $List.RootFolder.ServerRelativeUrl

# Get all FILES only (FSObjType 0), page by page for large libraries
$Items = Get-PnPListItem -List $LibraryName -PageSize 2000 |
         Where-Object { $_.FileSystemObjectType -eq "File" }

Write-Host "Found $($Items.Count) files. Starting download..." -ForegroundColor Cyan

$Counter = 0
foreach ($Item in $Items) {

    $Counter++
    $FileUrl = $Item.FieldValues.FileRef

    # Recreate the SharePoint folder structure locally
    $RelativePath = $FileUrl.Replace($LibraryUrl, "").Replace("/", "\")
    $LocalFile    = Join-Path $DownloadPath $RelativePath.TrimStart("\")
    $LocalFolder  = Split-Path $LocalFile -Parent

    if (-not (Test-Path $LocalFolder)) {
        New-Item -Path $LocalFolder -ItemType Directory -Force | Out-Null
    }

    Write-Progress -Activity "Downloading files" `
                   -Status "$Counter of $($Items.Count): $($Item.FieldValues.FileLeafRef)" `
                   -PercentComplete (($Counter / $Items.Count) * 100)

    try {
        Get-PnPFile -Url $FileUrl -Path $LocalFolder `
                    -FileName $Item.FieldValues.FileLeafRef -AsFile -Force
    }
    catch {
        Write-Host "Failed: $FileUrl - $($_.Exception.Message)" -ForegroundColor Red
    }
}

Write-Host "Download complete. Files saved to $DownloadPath" -ForegroundColor Green
Disconnect-PnPOnline

How this script works:

• Get-PnPListItem with -PageSize 2000 pulls items in batches so you don’t hit the 5,000 item list view threshold.
• FileSystemObjectType -eq "File" filters out folder objects, so you only process actual documents.
• FileRef is the server-relative URL of the file (for example, /sites/Finance/Shared Documents/2024/Report.pdf).
• Replacing the library URL with an empty string gives you the relative path, which is then used to recreate the folder tree locally.
• -AsFile -Force writes the file to disk and overwrites it if it already exists.

That’s it. Run it once and your entire library lands on your local drive with folders intact.

You can see the screenshot below for your reference.

Check out Upload File to SharePoint Document Library With Metadata in SPFx

Download All Files Without Keeping the Folder Structure (Flat Download)

Sometimes you just want every file dumped into one folder. The problem is duplicate file names in different subfolders will overwrite each other.

The script below handles that by adding a numeric suffix when a duplicate name is found.

<#
=====================================================================
 Script  : Download all files from a SharePoint library (FLAT)
 Purpose : Downloads every file from a document library, including
           all subfolders, into ONE local folder without recreating
           the SharePoint folder structure.
 Requires: PowerShell 7+ and the PnP.PowerShell module
=====================================================================
#>

# ------------------------- CONFIGURATION -------------------------
$SiteURL      = "https://contoso.sharepoint.com/sites/Finance"
$ClientId     = "11111111-2222-3333-4444-555555555555"
$LibraryName  = "Documents"                       # Library display name
$DownloadPath = "C:\SPDownloads\Finance_Flat"     # Local flat folder
$MappingFile  = "C:\SPDownloads\FlatDownload_Map_$(Get-Date -f 'yyyyMMdd_HHmmss').csv"
$MaxRetries   = 3
$SkipExisting = $false    # $true = skip files already downloaded
# -----------------------------------------------------------------

# ---------- STEP 1: Connect to SharePoint ----------
try {
    Connect-PnPOnline -Url $SiteURL -Interactive -ClientId $ClientId -ErrorAction Stop
    Write-Host "Connected to $SiteURL" -ForegroundColor Green
}
catch {
    Write-Host "Connection failed: $($_.Exception.Message)" -ForegroundColor Red
    return
}

# ---------- STEP 2: Prepare the local download folder ----------
if (-not (Test-Path $DownloadPath)) {
    New-Item -Path $DownloadPath -ItemType Directory -Force | Out-Null
    Write-Host "Created folder: $DownloadPath" -ForegroundColor Gray
}

# ---------- STEP 3: Get every file in the library ----------
Write-Host "Reading library '$LibraryName'..." -ForegroundColor Cyan

$Items = Get-PnPListItem -List $LibraryName -PageSize 2000 `
         -Fields "FileRef", "FileLeafRef", "File_x0020_Size", "Modified" |
         Where-Object { $_.FileSystemObjectType -eq "File" }

$Total = @($Items).Count

if ($Total -eq 0) {
    Write-Host "No files found in '$LibraryName'. Nothing to download." -ForegroundColor Yellow
    Disconnect-PnPOnline
    return
}

Write-Host "Found $Total files. Starting flat download...`n" -ForegroundColor Cyan

# ---------- STEP 4: Download loop with duplicate-name handling ----------
$Downloaded = 0
$Skipped    = 0
$Failed     = 0
$Renamed    = 0
$Counter    = 0
$Mapping    = @()

foreach ($Item in $Items) {

    $Counter++
    $SourceUrl    = $Item.FieldValues.FileRef
    $OriginalName = $Item.FieldValues.FileLeafRef

    Write-Progress -Activity "Flat download from '$LibraryName'" `
                   -Status "$Counter of $Total : $OriginalName" `
                   -PercentComplete (($Counter / $Total) * 100)

    # --- Strip characters Windows does not allow in file names ---
    $SafeName = $OriginalName -replace '[\\/:*?"<>|]', '_'

    $TargetName = $SafeName
    $TargetPath = Join-Path $DownloadPath $TargetName

    # --- Optionally skip if the exact file already exists ---
    if ($SkipExisting -and (Test-Path $TargetPath)) {
        Write-Host "[$Counter/$Total] Skipped (exists): $TargetName" -ForegroundColor DarkGray
        $Skipped++
        continue
    }

    # --- Resolve duplicate names: File.pdf -> File_1.pdf -> File_2.pdf ---
    $Suffix = 1
    while (Test-Path $TargetPath) {
        $BaseName   = [System.IO.Path]::GetFileNameWithoutExtension($SafeName)
        $Extension  = [System.IO.Path]::GetExtension($SafeName)
        $TargetName = "$($BaseName)_$Suffix$Extension"
        $TargetPath = Join-Path $DownloadPath $TargetName
        $Suffix++
    }

    if ($TargetName -ne $SafeName) { $Renamed++ }

    # --- Download with retry + exponential back-off for throttling ---
    $Attempt = 0
    $Success = $false

    while (-not $Success -and $Attempt -lt $MaxRetries) {

        $Attempt++

        try {
            Get-PnPFile -Url $SourceUrl `
                        -Path $DownloadPath `
                        -FileName $TargetName `
                        -AsFile -Force -ErrorAction Stop

            $Success = $true
            $Downloaded++

            Write-Host "[$Counter/$Total] Downloaded: $TargetName" -ForegroundColor Green

            $Mapping += [PSCustomObject]@{
                OriginalName   = $OriginalName
                SavedAs        = $TargetName
                SharePointPath = $SourceUrl
                SizeKB         = [math]::Round([int64]$Item.FieldValues.File_x0020_Size / 1KB, 2)
                Modified       = $Item.FieldValues.Modified
                Status         = "Success"
            }
        }
        catch {
            if ($Attempt -ge $MaxRetries) {

                $Failed++
                Write-Host "[$Counter/$Total] FAILED: $OriginalName - $($_.Exception.Message)" -ForegroundColor Red

                $Mapping += [PSCustomObject]@{
                    OriginalName   = $OriginalName
                    SavedAs        = ""
                    SharePointPath = $SourceUrl
                    SizeKB         = 0
                    Modified       = $Item.FieldValues.Modified
                    Status         = "Failed: $($_.Exception.Message)"
                }
            }
            else {
                # Wait 10s, then 20s, then 40s before retrying
                Start-Sleep -Seconds ([math]::Pow(2, $Attempt) * 5)
            }
        }
    }
}

Write-Progress -Activity "Flat download" -Completed

# ---------- STEP 5: Export the mapping file ----------
if ($Mapping.Count -gt 0) {
    $Mapping | Export-Csv -Path $MappingFile -NoTypeInformation -Encoding UTF8
}

# ---------- STEP 6: Summary ----------
$LocalCount = (Get-ChildItem -Path $DownloadPath -File).Count

Write-Host "`n================ SUMMARY ================" -ForegroundColor Cyan
Write-Host " Library          : $LibraryName"
Write-Host " Files in library : $Total"
Write-Host " Downloaded       : $Downloaded" -ForegroundColor Green
Write-Host " Renamed (dupes)  : $Renamed"    -ForegroundColor Yellow
Write-Host " Skipped          : $Skipped"    -ForegroundColor DarkGray
Write-Host " Failed           : $Failed"     -ForegroundColor Red
Write-Host " Files on disk    : $LocalCount"
Write-Host " Mapping CSV      : $MappingFile"
Write-Host "=========================================`n" -ForegroundColor Cyan

Disconnect-PnPOnline

Check out Delete Files From SharePoint Document Library Using Rest API in Power Automate

Download Only PDF Files from a SharePoint Library

This is one of the most common requests. You only want the PDFs – not the Word docs, not the images.

The cleanest approach is to filter on the File_x0020_Type field, which stores the extension without the dot.

$PDFs = Get-PnPListItem -List $LibraryName -PageSize 2000 |
        Where-Object { $_.FieldValues.File_x0020_Type -eq "pdf" }

Write-Host "Found $($PDFs.Count) PDF files."

foreach ($Item in $PDFs) {
    Get-PnPFile -Url $Item.FieldValues.FileRef -Path $DownloadPath `
                -FileName $Item.FieldValues.FileLeafRef -AsFile -Force
}

Faster method using a CAML query

If your library has tens of thousands of items, filtering on the server side is dramatically faster because SharePoint returns only the matching rows:

$CAML = @"
<View Scope='RecursiveAll'>
  <Query>
    <Where>
      <Eq>
        <FieldRef Name='File_x0020_Type'/>
        <Value Type='Text'>pdf</Value>
      </Eq>
    </Where>
  </Query>
</View>
"@

$PDFs = Get-PnPListItem -List $LibraryName -Query $CAML -PageSize 2000

foreach ($Item in $PDFs) {
    Get-PnPFile -Url $Item.FieldValues.FileRef -Path $DownloadPath `
                -FileName $Item.FieldValues.FileLeafRef -AsFile -Force
}

Note: Scope='RecursiveAll' is important – without it, CAML only looks at the root folder and ignores subfolders.

Here is the complete PnP PowerShell script:

# ------------------------- CONFIGURATION -------------------------
$SiteURL      = "https://contoso.sharepoint.com/sites/Finance"
$ClientId     = "11111111-2222-3333-4444-555555555555"
$LibraryName  = "Documents"
$DownloadPath = "C:\SPDownloads\PDFs"
$KeepStructure = $true      # $true = recreate folders, $false = flat
$MaxRetries    = 3
$LogFile       = "C:\SPDownloads\PDFDownload_$(Get-Date -f 'yyyyMMdd_HHmmss').csv"
# -----------------------------------------------------------------

try {
    Connect-PnPOnline -Url $SiteURL -Interactive -ClientId $ClientId -ErrorAction Stop
    Write-Host "Connected to $SiteURL" -ForegroundColor Green
}
catch {
    Write-Host "Connection failed: $($_.Exception.Message)" -ForegroundColor Red
    return
}

if (-not (Test-Path $DownloadPath)) {
    New-Item -Path $DownloadPath -ItemType Directory -Force | Out-Null
}

$List       = Get-PnPList -Identity $LibraryName -Includes RootFolder
$LibraryUrl = $List.RootFolder.ServerRelativeUrl

$CAML = @"
<View Scope='RecursiveAll'>
  <Query>
    <Where>
      <Eq>
        <FieldRef Name='File_x0020_Type'/>
        <Value Type='Text'>pdf</Value>
      </Eq>
    </Where>
  </Query>
  <ViewFields>
    <FieldRef Name='FileRef'/>
    <FieldRef Name='FileLeafRef'/>
    <FieldRef Name='File_x0020_Size'/>
    <FieldRef Name='Modified'/>
  </ViewFields>
</View>
"@

Write-Host "Searching for PDF files in '$LibraryName'..." -ForegroundColor Cyan

$PDFs  = Get-PnPListItem -List $LibraryName -Query $CAML -PageSize 2000
$Total = @($PDFs).Count

if ($Total -eq 0) {
    Write-Host "No PDF files found." -ForegroundColor Yellow
    Disconnect-PnPOnline
    return
}

$TotalMB = [math]::Round((($PDFs | Measure-Object -Property { [int64]$_.FieldValues.File_x0020_Size } -Sum).Sum / 1MB), 2)
Write-Host "Found $Total PDF files ($TotalMB MB). Starting download...`n" -ForegroundColor Cyan

$Downloaded = 0
$Failed     = 0
$Counter    = 0
$Log        = @()

foreach ($Item in $PDFs) {

    $Counter   = $Counter + 1
    $SourceUrl = $Item.FieldValues.FileRef
    $FileName  = $Item.FieldValues.FileLeafRef -replace '[\\/:*?"<>|]', '_'

    if ($KeepStructure) {
        $RelPath     = $SourceUrl.Replace($LibraryUrl, "").Replace("/", "\").TrimStart("\")
        $TargetFolder = Split-Path (Join-Path $DownloadPath $RelPath) -Parent
    }
    else {
        $TargetFolder = $DownloadPath
        $Suffix = 1
        while (Test-Path (Join-Path $TargetFolder $FileName)) {
            $Base     = [System.IO.Path]::GetFileNameWithoutExtension($Item.FieldValues.FileLeafRef)
            $FileName = "$($Base)_$Suffix.pdf"
            $Suffix   = $Suffix + 1
        }
    }

    if (-not (Test-Path $TargetFolder)) {
        New-Item -Path $TargetFolder -ItemType Directory -Force | Out-Null
    }

    Write-Progress -Activity "Downloading PDFs from '$LibraryName'" `
                   -Status "$Counter of $Total : $FileName" `
                   -PercentComplete (($Counter / $Total) * 100)

    $Attempt = 0
    $Success = $false

    while (-not $Success -and $Attempt -lt $MaxRetries) {

        $Attempt = $Attempt + 1

        try {
            Get-PnPFile -Url $SourceUrl -Path $TargetFolder -FileName $FileName -AsFile -Force -ErrorAction Stop
            $Success    = $true
            $Downloaded = $Downloaded + 1

            $SizeKB = [math]::Round([int64]$Item.FieldValues.File_x0020_Size / 1KB, 2)
            Write-Host "[$Counter/$Total] $FileName ($SizeKB KB)" -ForegroundColor Green

            $Log += [PSCustomObject]@{
                FileName       = $FileName
                SharePointPath = $SourceUrl
                SizeKB         = $SizeKB
                Modified       = $Item.FieldValues.Modified
                Status         = "Success"
            }
        }
        catch {
            if ($Attempt -ge $MaxRetries) {
                $Failed = $Failed + 1
                Write-Host "[$Counter/$Total] FAILED: $FileName" -ForegroundColor Red

                $Log += [PSCustomObject]@{
                    FileName       = $FileName
                    SharePointPath = $SourceUrl
                    SizeKB         = 0
                    Modified       = $Item.FieldValues.Modified
                    Status         = "Failed: $($_.Exception.Message)"
                }
            }
            else {
                Start-Sleep -Seconds ([math]::Pow(2, $Attempt) * 5)
            }
        }
    }
}

Write-Progress -Activity "Downloading PDFs" -Completed

if ($Log.Count -gt 0) {
    $Log | Export-Csv -Path $LogFile -NoTypeInformation -Encoding UTF8
}

Write-Host "`n============== SUMMARY ==============" -ForegroundColor Cyan
Write-Host " PDFs found  : $Total"
Write-Host " Downloaded  : $Downloaded" -ForegroundColor Green
Write-Host " Failed      : $Failed"     -ForegroundColor Red
Write-Host " Total size  : $TotalMB MB"
Write-Host " Saved to    : $DownloadPath"
Write-Host " Log file    : $LogFile"
Write-Host "=====================================`n" -ForegroundColor Cyan

Disconnect-PnPOnline

Read Create Folders and Subfolders in SharePoint document library

Download Only Excel Files (or Any Set of File Types)

Excel files can be .xlsx, .xls, .xlsm, or .csv, so you need to check for multiple extensions.

$Extensions = @("xlsx", "xls", "xlsm", "csv")

$ExcelFiles = Get-PnPListItem -List $LibraryName -PageSize 2000 |
              Where-Object { $Extensions -contains $_.FieldValues.File_x0020_Type }

foreach ($Item in $ExcelFiles) {
    Get-PnPFile -Url $Item.FieldValues.FileRef -Path $DownloadPath `
                -FileName $Item.FieldValues.FileLeafRef -AsFile -Force
}

You can reuse this pattern for any file type. For Word documents use @("docx","doc"), for images use @("jpg","jpeg","png","gif"), and for PowerPoint use @("pptx","ppt").

Download Files Larger Than 5 MB

Useful when you’re cleaning up storage or auditing which large files are eating your site quota.

The file size is stored in the File_x0020_Size field, in bytes.

$MinSizeMB = 5
$MinBytes  = $MinSizeMB * 1MB

$BigFiles = Get-PnPListItem -List $LibraryName -PageSize 2000 |
            Where-Object {
                $_.FileSystemObjectType -eq "File" -and
                [int64]$_.FieldValues.File_x0020_Size -gt $MinBytes
            }

Write-Host "Files larger than $MinSizeMB MB: $($BigFiles.Count)"

foreach ($Item in $BigFiles) {
    $SizeMB = [math]::Round([int64]$Item.FieldValues.File_x0020_Size / 1MB, 2)
    Write-Host "Downloading $($Item.FieldValues.FileLeafRef) ($SizeMB MB)"

    Get-PnPFile -Url $Item.FieldValues.FileRef -Path $DownloadPath `
                -FileName $Item.FieldValues.FileLeafRef -AsFile -Force
}

Tip: If you only want a report of large files (without downloading them), replace the download line with an export:

$BigFiles | ForEach-Object {
    [PSCustomObject]@{
        Name   = $_.FieldValues.FileLeafRef
        SizeMB = [math]::Round([int64]$_.FieldValues.File_x0020_Size / 1MB, 2)
        Path   = $_.FieldValues.FileRef
    }
} | Export-Csv "C:\Reports\LargeFiles.csv" -NoTypeInformation

Here is the complete PnP PowerShell script:

# ------------------------- CONFIGURATION -------------------------
$SiteURL       = "https://contoso.sharepoint.com/sites/Finance"
$ClientId      = "11111111-2222-3333-4444-555555555555"
$LibraryName   = "Documents"
$DownloadPath  = "C:\SPDownloads\LargeFiles"
$MinSizeMB     = 5
$KeepStructure = $true
$MaxRetries    = 3
$LogFile       = "C:\SPDownloads\LargeFiles_$(Get-Date -f 'yyyyMMdd_HHmmss').csv"
# -----------------------------------------------------------------

$MinBytes = $MinSizeMB * 1MB

try {
    Connect-PnPOnline -Url $SiteURL -Interactive -ClientId $ClientId -ErrorAction Stop
    Write-Host "Connected to $SiteURL" -ForegroundColor Green
}
catch {
    Write-Host "Connection failed: $($_.Exception.Message)" -ForegroundColor Red
    return
}

if (-not (Test-Path $DownloadPath)) {
    New-Item -Path $DownloadPath -ItemType Directory -Force | Out-Null
}

$List       = Get-PnPList -Identity $LibraryName -Includes RootFolder
$LibraryUrl = $List.RootFolder.ServerRelativeUrl

$CAML = @"
<View Scope='RecursiveAll'>
  <Query>
    <Where>
      <Gt>
        <FieldRef Name='File_x0020_Size'/>
        <Value Type='Number'>$MinBytes</Value>
      </Gt>
    </Where>
    <OrderBy>
      <FieldRef Name='File_x0020_Size' Ascending='FALSE'/>
    </OrderBy>
  </Query>
  <ViewFields>
    <FieldRef Name='FileRef'/>
    <FieldRef Name='FileLeafRef'/>
    <FieldRef Name='File_x0020_Size'/>
    <FieldRef Name='File_x0020_Type'/>
    <FieldRef Name='Modified'/>
  </ViewFields>
</View>
"@

Write-Host "Searching for files larger than $MinSizeMB MB..." -ForegroundColor Cyan

$BigFiles = Get-PnPListItem -List $LibraryName -Query $CAML -PageSize 2000 |
            Where-Object { $_.FileSystemObjectType -eq "File" }

$Total = @($BigFiles).Count

if ($Total -eq 0) {
    Write-Host "No files larger than $MinSizeMB MB found." -ForegroundColor Yellow
    Disconnect-PnPOnline
    return
}

$TotalMB = [math]::Round((($BigFiles | ForEach-Object { [int64]$_.FieldValues.File_x0020_Size } | Measure-Object -Sum).Sum / 1MB), 2)
$TotalGB = [math]::Round($TotalMB / 1024, 2)

Write-Host "Found $Total files larger than $MinSizeMB MB" -ForegroundColor Cyan
Write-Host "Total download size: $TotalMB MB ($TotalGB GB)`n" -ForegroundColor Cyan

$Confirm = Read-Host "Continue with download? (Y/N)"
if ($Confirm -ne "Y") {
    Write-Host "Cancelled by user." -ForegroundColor Yellow
    Disconnect-PnPOnline
    return
}

$Downloaded    = 0
$Failed        = 0
$Counter       = 0
$BytesDone     = 0
$Log           = @()
$StartTime     = Get-Date

foreach ($Item in $BigFiles) {

    $Counter   = $Counter + 1
    $SourceUrl = $Item.FieldValues.FileRef
    $FileName  = $Item.FieldValues.FileLeafRef -replace '[\\/:*?"<>|]', '_'
    $Bytes     = [int64]$Item.FieldValues.File_x0020_Size
    $SizeMB    = [math]::Round($Bytes / 1MB, 2)

    if ($KeepStructure) {
        $RelPath      = $SourceUrl.Replace($LibraryUrl, "").Replace("/", "\").TrimStart("\")
        $TargetFolder = Split-Path (Join-Path $DownloadPath $RelPath) -Parent
    }
    else {
        $TargetFolder = $DownloadPath
        $Suffix = 1
        while (Test-Path (Join-Path $TargetFolder $FileName)) {
            $Base      = [System.IO.Path]::GetFileNameWithoutExtension($Item.FieldValues.FileLeafRef)
            $Ext       = [System.IO.Path]::GetExtension($Item.FieldValues.FileLeafRef)
            $FileName  = "$($Base)_$Suffix$Ext"
            $Suffix    = $Suffix + 1
        }
    }

    if (-not (Test-Path $TargetFolder)) {
        New-Item -Path $TargetFolder -ItemType Directory -Force | Out-Null
    }

    $PctDone = [math]::Round(($BytesDone / ($TotalMB * 1MB)) * 100, 1)

    Write-Progress -Activity "Downloading files over $MinSizeMB MB" `
                   -Status "$Counter of $Total : $FileName ($SizeMB MB) - $PctDone% of data" `
                   -PercentComplete (($Counter / $Total) * 100)

    $Attempt = 0
    $Success = $false

    while (-not $Success -and $Attempt -lt $MaxRetries) {

        $Attempt = $Attempt + 1

        try {
            Get-PnPFile -Url $SourceUrl -Path $TargetFolder -FileName $FileName -AsFile -Force -ErrorAction Stop

            $Success    = $true
            $Downloaded = $Downloaded + 1
            $BytesDone  = $BytesDone + $Bytes

            Write-Host "[$Counter/$Total] $FileName ($SizeMB MB)" -ForegroundColor Green

            $Log += [PSCustomObject]@{
                FileName       = $FileName
                SizeMB         = $SizeMB
                FileType       = $Item.FieldValues.File_x0020_Type
                SharePointPath = $SourceUrl
                Modified       = $Item.FieldValues.Modified
                Status         = "Success"
            }
        }
        catch {
            if ($Attempt -ge $MaxRetries) {
                $Failed = $Failed + 1
                Write-Host "[$Counter/$Total] FAILED: $FileName ($SizeMB MB)" -ForegroundColor Red

                $Log += [PSCustomObject]@{
                    FileName       = $FileName
                    SizeMB         = $SizeMB
                    FileType       = $Item.FieldValues.File_x0020_Type
                    SharePointPath = $SourceUrl
                    Modified       = $Item.FieldValues.Modified
                    Status         = "Failed: $($_.Exception.Message)"
                }
            }
            else {
                Start-Sleep -Seconds ([math]::Pow(2, $Attempt) * 5)
            }
        }
    }
}

Write-Progress -Activity "Downloading large files" -Completed

if ($Log.Count -gt 0) {
    $Log | Export-Csv -Path $LogFile -NoTypeInformation -Encoding UTF8
}

$Elapsed      = (Get-Date) - $StartTime
$DownloadedMB = [math]::Round($BytesDone / 1MB, 2)
$SpeedMBps    = if ($Elapsed.TotalSeconds -gt 0) { [math]::Round($DownloadedMB / $Elapsed.TotalSeconds, 2) } else { 0 }

Write-Host "`n================ SUMMARY ================" -ForegroundColor Cyan
Write-Host " Size threshold : $MinSizeMB MB"
Write-Host " Files found    : $Total"
Write-Host " Downloaded     : $Downloaded" -ForegroundColor Green
Write-Host " Failed         : $Failed"     -ForegroundColor Red
Write-Host " Data pulled    : $DownloadedMB MB"
Write-Host " Elapsed        : $($Elapsed.ToString('hh\:mm\:ss'))"
Write-Host " Avg speed      : $SpeedMBps MB/s"
Write-Host " Saved to       : $DownloadPath"
Write-Host " Log file       : $LogFile"
Write-Host "=========================================`n" -ForegroundColor Cyan

Disconnect-PnPOnline

Here, the first script pulls every item in the library and then filters in PowerShell. That works, but on a 50,000-item library you’re transferring metadata for all 50,000 items just to find the 300 that are over 5 MB.

The CAML version pushes the File_x0020_Size comparison to the server. SharePoint returns only the matching items. The <OrderBy> clause also sorts largest-first, so you see the biggest offenders immediately and can cancel early if the total looks wrong.

One thing to note: File_x0020_Size is not stored on folder objects, so the Where-Object { $_.FileSystemObjectType -eq "File" } line stays in as a safety filter.

Files Between 5 MB and 100 MB

$MinBytes = 5MB
$MaxBytes = 100MB

$CAML = @"
<View Scope='RecursiveAll'>
  <Query>
    <Where>
      <And>
        <Gt><FieldRef Name='File_x0020_Size'/><Value Type='Number'>$MinBytes</Value></Gt>
        <Lt><FieldRef Name='File_x0020_Size'/><Value Type='Number'>$MaxBytes</Value></Lt>
      </And>
    </Where>
  </Query>
</View>
"@

Large Files of a Specific Type

$MinBytes = 5MB

$CAML = @"
<View Scope='RecursiveAll'>
  <Query>
    <Where>
      <And>
        <Gt><FieldRef Name='File_x0020_Size'/><Value Type='Number'>$MinBytes</Value></Gt>
        <Eq><FieldRef Name='File_x0020_Type'/><Value Type='Text'>mp4</Value></Eq>
      </And>
    </Where>
  </Query>
</View>
"@

Large Files Not Modified in Over a Year

$MinBytes = 5MB
$CutOff   = (Get-Date).AddYears(-1).ToString("yyyy-MM-ddTHH:mm:ssZ")

$CAML = @"
<View Scope='RecursiveAll'>
  <Query>
    <Where>
      <And>
        <Gt><FieldRef Name='File_x0020_Size'/><Value Type='Number'>$MinBytes</Value></Gt>
        <Leq><FieldRef Name='Modified'/><Value Type='DateTime' IncludeTimeValue='TRUE'>$CutOff</Value></Leq>
      </And>
    </Where>
  </Query>
</View>
"@

Check out Create and Delete SharePoint Document Library Using PowerShell

Download Files from a Specific Folder in SharePoint

If you only need one folder (and not the entire library), use Get-PnPFolderItem. This is much faster because it doesn’t scan the whole library.

Download files from one folder only (no subfolders):

$FolderUrl    = "/sites/Finance/Shared Documents/2025/Q1 Reports"
$DownloadPath = "C:\SPDownloads\Q1Reports"

New-Item -Path $DownloadPath -ItemType Directory -Force | Out-Null

$Files = Get-PnPFolderItem -FolderSiteRelativeUrl "Shared Documents/2025/Q1 Reports" -ItemType File

foreach ($File in $Files) {
    Get-PnPFile -Url $File.ServerRelativeUrl -Path $DownloadPath `
                -FileName $File.Name -AsFile -Force
}

Here is the complete PnP PowerShell script:

# ------------------------- CONFIGURATION -------------------------
$SiteURL      = "https://contoso.sharepoint.com/sites/Finance"
$ClientId     = "11111111-2222-3333-4444-555555555555"
$FolderUrl    = "/sites/Finance/Shared Documents/2025/Q1 Reports"
$SiteRelative = "Shared Documents/2025/Q1 Reports"
$DownloadPath = "C:\SPDownloads\Q1Reports"
$IncludeSubfolders = $false
$MaxRetries   = 3
$LogFile      = "C:\SPDownloads\FolderDownload_$(Get-Date -f 'yyyyMMdd_HHmmss').csv"
# -----------------------------------------------------------------

try {
    Connect-PnPOnline -Url $SiteURL -Interactive -ClientId $ClientId -ErrorAction Stop
    Write-Host "Connected to $SiteURL" -ForegroundColor Green
}
catch {
    Write-Host "Connection failed: $($_.Exception.Message)" -ForegroundColor Red
    return
}

if (-not (Test-Path $DownloadPath)) {
    New-Item -Path $DownloadPath -ItemType Directory -Force | Out-Null
}

function Get-FilesRecursive {
    param (
        [string]$RelativeUrl,
        [string]$LocalPath
    )

    if (-not (Test-Path $LocalPath)) {
        New-Item -Path $LocalPath -ItemType Directory -Force | Out-Null
    }

    $Items = Get-PnPFolderItem -FolderSiteRelativeUrl $RelativeUrl -ItemType File
    foreach ($Item in $Items) {
        [PSCustomObject]@{
            Name      = $Item.Name
            Url       = $Item.ServerRelativeUrl
            Length    = $Item.Length
            LocalPath = $LocalPath
        }
    }

    if ($IncludeSubfolders) {
        $SubFolders = Get-PnPFolderItem -FolderSiteRelativeUrl $RelativeUrl -ItemType Folder |
                      Where-Object { $_.Name -ne "Forms" }

        foreach ($Sub in $SubFolders) {
            Get-FilesRecursive -RelativeUrl "$RelativeUrl/$($Sub.Name)" -LocalPath (Join-Path $LocalPath $Sub.Name)
        }
    }
}

Write-Host "Reading folder '$FolderUrl'..." -ForegroundColor Cyan

$Files = @(Get-FilesRecursive -RelativeUrl $SiteRelative -LocalPath $DownloadPath)
$Total = $Files.Count

if ($Total -eq 0) {
    Write-Host "No files found in the specified folder." -ForegroundColor Yellow
    Disconnect-PnPOnline
    return
}

$TotalMB = [math]::Round((($Files | Measure-Object -Property Length -Sum).Sum / 1MB), 2)
Write-Host "Found $Total files ($TotalMB MB). Starting download...`n" -ForegroundColor Cyan

$Downloaded = 0
$Failed     = 0
$Counter    = 0
$Log        = @()

foreach ($File in $Files) {

    $Counter  = $Counter + 1
    $FileName = $File.Name -replace '[\\/:*?"<>|]', '_'
    $SizeMB   = [math]::Round($File.Length / 1MB, 2)

    Write-Progress -Activity "Downloading from '$SiteRelative'" `
                   -Status "$Counter of $Total : $FileName" `
                   -PercentComplete (($Counter / $Total) * 100)

    $Attempt = 0
    $Success = $false

    while (-not $Success -and $Attempt -lt $MaxRetries) {

        $Attempt = $Attempt + 1

        try {
            Get-PnPFile -Url $File.Url -Path $File.LocalPath -FileName $FileName -AsFile -Force -ErrorAction Stop

            $Success    = $true
            $Downloaded = $Downloaded + 1

            Write-Host "[$Counter/$Total] $FileName ($SizeMB MB)" -ForegroundColor Green

            $Log += [PSCustomObject]@{
                FileName       = $FileName
                SizeMB         = $SizeMB
                SharePointPath = $File.Url
                LocalFolder    = $File.LocalPath
                Status         = "Success"
            }
        }
        catch {
            if ($Attempt -ge $MaxRetries) {
                $Failed = $Failed + 1
                Write-Host "[$Counter/$Total] FAILED: $FileName" -ForegroundColor Red

                $Log += [PSCustomObject]@{
                    FileName       = $FileName
                    SizeMB         = $SizeMB
                    SharePointPath = $File.Url
                    LocalFolder    = $File.LocalPath
                    Status         = "Failed: $($_.Exception.Message)"
                }
            }
            else {
                Start-Sleep -Seconds ([math]::Pow(2, $Attempt) * 5)
            }
        }
    }
}

Write-Progress -Activity "Downloading folder" -Completed

if ($Log.Count -gt 0) {
    $Log | Export-Csv -Path $LogFile -NoTypeInformation -Encoding UTF8
}

Write-Host "`n============== SUMMARY ==============" -ForegroundColor Cyan
Write-Host " Source folder : $FolderUrl"
Write-Host " Subfolders    : $IncludeSubfolders"
Write-Host " Files found   : $Total"
Write-Host " Downloaded    : $Downloaded" -ForegroundColor Green
Write-Host " Failed        : $Failed"     -ForegroundColor Red
Write-Host " Total size    : $TotalMB MB"
Write-Host " Saved to      : $DownloadPath"
Write-Host " Log file      : $LogFile"
Write-Host "=====================================`n" -ForegroundColor Cyan

Disconnect-PnPOnline

Download a folder including all its subfolders (recursive):

$FolderUrl    = "/sites/Finance/Shared Documents/2025"
$DownloadPath = "C:\SPDownloads\2025"

function Download-SPFolder {
    param($SPFolderUrl, $LocalPath)

    if (-not (Test-Path $LocalPath)) {
        New-Item -Path $LocalPath -ItemType Directory -Force | Out-Null
    }

    # Download files in the current folder
    Get-PnPFolderItem -FolderSiteRelativeUrl $SPFolderUrl -ItemType File | ForEach-Object {
        Get-PnPFile -Url $_.ServerRelativeUrl -Path $LocalPath -FileName $_.Name -AsFile -Force
        Write-Host "Downloaded: $($_.Name)"
    }

    # Recurse into subfolders
    Get-PnPFolderItem -FolderSiteRelativeUrl $SPFolderUrl -ItemType Folder | ForEach-Object {
        Download-SPFolder -SPFolderUrl "$SPFolderUrl/$($_.Name)" `
                          -LocalPath (Join-Path $LocalPath $_.Name)
    }
}

Download-SPFolder -SPFolderUrl "Shared Documents/2025" -LocalPath $DownloadPath

Note: -FolderSiteRelativeUrl is relative to the site, not the server. So use Shared Documents/2025, not /sites/Finance/Shared Documents/2025.

Check out Get SharePoint Folder Permissions Using PnP PowerShell

Download Files Older Than 30 Days

Perfect for archiving. This filters on the Modified date, but you can switch to Created just as easily.

$DaysOld  = 30
$CutOff   = (Get-Date).AddDays(-$DaysOld)

$OldFiles = Get-PnPListItem -List $LibraryName -PageSize 2000 |
            Where-Object {
                $_.FileSystemObjectType -eq "File" -and
                [datetime]$_.FieldValues.Modified -lt $CutOff
            }

Write-Host "Files older than $DaysOld days: $($OldFiles.Count)"

foreach ($Item in $OldFiles) {
    Get-PnPFile -Url $Item.FieldValues.FileRef -Path $DownloadPath `
                -FileName $Item.FieldValues.FileLeafRef -AsFile -Force
}

Server-side version using CAML (faster on big libraries):

$CutOffString = (Get-Date).AddDays(-30).ToString("yyyy-MM-ddTHH:mm:ssZ")

$CAML = @"
<View Scope='RecursiveAll'>
  <Query>
    <Where>
      <Lt>
        <FieldRef Name='Modified'/>
        <Value Type='DateTime' IncludeTimeValue='TRUE'>$CutOffString</Value>
      </Lt>
    </Where>
  </Query>
</View>
"@

$OldFiles = Get-PnPListItem -List $LibraryName -Query $CAML -PageSize 2000

Download Files Modified in the Last 7 Days (Incremental Download)

This is the reverse of the above and is extremely useful if you’re running a scheduled sync job – you only pull what changed.

$Since = (Get-Date).AddDays(-7)

$RecentFiles = Get-PnPListItem -List $LibraryName -PageSize 2000 |
               Where-Object {
                   $_.FileSystemObjectType -eq "File" -and
                   [datetime]$_.FieldValues.Modified -ge $Since
               }

foreach ($Item in $RecentFiles) {
    Get-PnPFile -Url $Item.FieldValues.FileRef -Path $DownloadPath `
                -FileName $Item.FieldValues.FileLeafRef -AsFile -Force
}

Even smarter – skip files that haven’t changed locally:

foreach ($Item in $Items) {
    $LocalFile = Join-Path $DownloadPath $Item.FieldValues.FileLeafRef
    $SPModified = [datetime]$Item.FieldValues.Modified

    if (Test-Path $LocalFile) {
        $LocalModified = (Get-Item $LocalFile).LastWriteTime
        if ($LocalModified -ge $SPModified) {
            Write-Host "Skipping (unchanged): $($Item.FieldValues.FileLeafRef)" -ForegroundColor DarkGray
            continue
        }
    }

    Get-PnPFile -Url $Item.FieldValues.FileRef -Path $DownloadPath `
                -FileName $Item.FieldValues.FileLeafRef -AsFile -Force
}

Download Files Created or Modified by a Specific User

Handy during offboarding, when you need to collect everything a departing employee uploaded.

$TargetUser = "john.doe@contoso.com"

$UserFiles = Get-PnPListItem -List $LibraryName -PageSize 2000 |
             Where-Object {
                 $_.FileSystemObjectType -eq "File" -and
                 $_.FieldValues.Author.Email -eq $TargetUser
             }

foreach ($Item in $UserFiles) {
    Get-PnPFile -Url $Item.FieldValues.FileRef -Path $DownloadPath `
                -FileName $Item.FieldValues.FileLeafRef -AsFile -Force
}

Change Author to Editor if you want files last modified by that person instead of files they created.

Here is the complete PnP PowerShell script:

# ------------------------- CONFIGURATION -------------------------
$SiteURL       = "https://contoso.sharepoint.com/sites/Finance"
$ClientId      = "11111111-2222-3333-4444-555555555555"
$LibraryName   = "Documents"
$DownloadPath  = "C:\SPDownloads\UserFiles"
$TargetUser    = "john.doe@contoso.com"
$MatchField    = "Author"        # Author = created by, Editor = last modified by
$KeepStructure = $true
$MaxRetries    = 3
$LogFile       = "C:\SPDownloads\UserFiles_$(Get-Date -f 'yyyyMMdd_HHmmss').csv"
# -----------------------------------------------------------------

try {
    Connect-PnPOnline -Url $SiteURL -Interactive -ClientId $ClientId -ErrorAction Stop
    Write-Host "Connected to $SiteURL" -ForegroundColor Green
}
catch {
    Write-Host "Connection failed: $($_.Exception.Message)" -ForegroundColor Red
    return
}

try {
    $User   = Get-PnPUser | Where-Object { $_.Email -eq $TargetUser }
    if ($null -eq $User) {
        $User = New-PnPUser -LoginName $TargetUser -ErrorAction Stop
    }
    $UserId = $User.Id
    Write-Host "Resolved user '$TargetUser' to ID $UserId" -ForegroundColor Gray
}
catch {
    Write-Host "Could not resolve user '$TargetUser': $($_.Exception.Message)" -ForegroundColor Red
    Disconnect-PnPOnline
    return
}

if (-not (Test-Path $DownloadPath)) {
    New-Item -Path $DownloadPath -ItemType Directory -Force | Out-Null
}

$List       = Get-PnPList -Identity $LibraryName -Includes RootFolder
$LibraryUrl = $List.RootFolder.ServerRelativeUrl

$CAML = @"
<View Scope='RecursiveAll'>
  <Query>
    <Where>
      <Eq>
        <FieldRef Name='$MatchField' LookupId='TRUE'/>
        <Value Type='Integer'>$UserId</Value>
      </Eq>
    </Where>
  </Query>
  <ViewFields>
    <FieldRef Name='FileRef'/>
    <FieldRef Name='FileLeafRef'/>
    <FieldRef Name='File_x0020_Size'/>
    <FieldRef Name='Author'/>
    <FieldRef Name='Editor'/>
    <FieldRef Name='Created'/>
    <FieldRef Name='Modified'/>
  </ViewFields>
</View>
"@

Write-Host "Searching for files where $MatchField = $TargetUser..." -ForegroundColor Cyan

$UserFiles = Get-PnPListItem -List $LibraryName -Query $CAML -PageSize 2000 |
             Where-Object { $_.FileSystemObjectType -eq "File" }

$Total = @($UserFiles).Count

if ($Total -eq 0) {
    Write-Host "No files found for user '$TargetUser'." -ForegroundColor Yellow
    Disconnect-PnPOnline
    return
}

$TotalMB = [math]::Round((($UserFiles | ForEach-Object { [int64]$_.FieldValues.File_x0020_Size } | Measure-Object -Sum).Sum / 1MB), 2)
Write-Host "Found $Total files ($TotalMB MB). Starting download...`n" -ForegroundColor Cyan

$Downloaded = 0
$Failed     = 0
$Counter    = 0
$Log        = @()

foreach ($Item in $UserFiles) {

    $Counter   = $Counter + 1
    $SourceUrl = $Item.FieldValues.FileRef
    $FileName  = $Item.FieldValues.FileLeafRef -replace '[\\/:*?"<>|]', '_'
    $SizeMB    = [math]::Round([int64]$Item.FieldValues.File_x0020_Size / 1MB, 2)

    if ($KeepStructure) {
        $RelPath      = $SourceUrl.Replace($LibraryUrl, "").Replace("/", "\").TrimStart("\")
        $TargetFolder = Split-Path (Join-Path $DownloadPath $RelPath) -Parent
    }
    else {
        $TargetFolder = $DownloadPath
        $Suffix = 1
        while (Test-Path (Join-Path $TargetFolder $FileName)) {
            $Base     = [System.IO.Path]::GetFileNameWithoutExtension($Item.FieldValues.FileLeafRef)
            $Ext      = [System.IO.Path]::GetExtension($Item.FieldValues.FileLeafRef)
            $FileName = "$($Base)_$Suffix$Ext"
            $Suffix   = $Suffix + 1
        }
    }

    if (-not (Test-Path $TargetFolder)) {
        New-Item -Path $TargetFolder -ItemType Directory -Force | Out-Null
    }

    Write-Progress -Activity "Downloading files for $TargetUser" `
                   -Status "$Counter of $Total : $FileName" `
                   -PercentComplete (($Counter / $Total) * 100)

    $Attempt = 0
    $Success = $false

    while (-not $Success -and $Attempt -lt $MaxRetries) {

        $Attempt = $Attempt + 1

        try {
            Get-PnPFile -Url $SourceUrl -Path $TargetFolder -FileName $FileName -AsFile -Force -ErrorAction Stop

            $Success    = $true
            $Downloaded = $Downloaded + 1

            Write-Host "[$Counter/$Total] $FileName ($SizeMB MB)" -ForegroundColor Green

            $Log += [PSCustomObject]@{
                FileName       = $FileName
                SizeMB         = $SizeMB
                CreatedBy      = $Item.FieldValues.Author.LookupValue
                ModifiedBy     = $Item.FieldValues.Editor.LookupValue
                Created        = $Item.FieldValues.Created
                Modified       = $Item.FieldValues.Modified
                SharePointPath = $SourceUrl
                Status         = "Success"
            }
        }
        catch {
            if ($Attempt -ge $MaxRetries) {
                $Failed = $Failed + 1
                Write-Host "[$Counter/$Total] FAILED: $FileName" -ForegroundColor Red

                $Log += [PSCustomObject]@{
                    FileName       = $FileName
                    SizeMB         = $SizeMB
                    CreatedBy      = $Item.FieldValues.Author.LookupValue
                    ModifiedBy     = $Item.FieldValues.Editor.LookupValue
                    Created        = $Item.FieldValues.Created
                    Modified       = $Item.FieldValues.Modified
                    SharePointPath = $SourceUrl
                    Status         = "Failed: $($_.Exception.Message)"
                }
            }
            else {
                Start-Sleep -Seconds ([math]::Pow(2, $Attempt) * 5)
            }
        }
    }
}

Write-Progress -Activity "Downloading user files" -Completed

if ($Log.Count -gt 0) {
    $Log | Export-Csv -Path $LogFile -NoTypeInformation -Encoding UTF8
}

Write-Host "`n============== SUMMARY ==============" -ForegroundColor Cyan
Write-Host " User        : $TargetUser"
Write-Host " Match field : $MatchField"
Write-Host " Files found : $Total"
Write-Host " Downloaded  : $Downloaded" -ForegroundColor Green
Write-Host " Failed      : $Failed"     -ForegroundColor Red
Write-Host " Total size  : $TotalMB MB"
Write-Host " Saved to    : $DownloadPath"
Write-Host " Log file    : $LogFile"
Write-Host "=====================================`n" -ForegroundColor Cyan

Disconnect-PnPOnline

Download Files Based on a Metadata Column Value

Most real-world libraries have custom columns like Department, Status, or Project. You can filter on those too.

# Download only files where the "Status" choice column equals "Approved"
$Approved = Get-PnPListItem -List $LibraryName -PageSize 2000 |
            Where-Object { $_.FieldValues.Status -eq "Approved" }

foreach ($Item in $Approved) {
    Get-PnPFile -Url $Item.FieldValues.FileRef -Path $DownloadPath `
                -FileName $Item.FieldValues.FileLeafRef -AsFile -Force
}

Not sure of the internal column name? Run this to list them:

Get-PnPField -List $LibraryName |
    Select-Object Title, InternalName, TypeAsString |
    Sort-Object Title

Note: Always use the InternalName in your scripts, not the display name. Spaces become _x0020_ in internal names.

Check out Add More Than 5000 Items to a SharePoint Online List Using PnP PowerShell

Download Files by Name Pattern (Wildcard Search)

Need all files with “Invoice” in the name? Use a simple -like match.

$Pattern = "*Invoice*"

$Matched = Get-PnPListItem -List $LibraryName -PageSize 2000 |
           Where-Object {
               $_.FileSystemObjectType -eq "File" -and
               $_.FieldValues.FileLeafRef -like $Pattern
           }

foreach ($Item in $Matched) {
    Get-PnPFile -Url $Item.FieldValues.FileRef -Path $DownloadPath `
                -FileName $Item.FieldValues.FileLeafRef -AsFile -Force
}

Download a Single File from SharePoint

If you just need one specific document, you don’t need any loops at all:

Get-PnPFile -Url "/sites/Finance/Shared Documents/Budget 2025.xlsx" `
            -Path "C:\SPDownloads" `
            -FileName "Budget 2025.xlsx" -AsFile -Force

You can also grab the file’s contents directly into memory instead of saving it:

$Content = Get-PnPFile -Url "/sites/Finance/Shared Documents/Notes.txt" -AsString
Write-Host $Content

Download All Files and Zip Them Automatically

Great for handing over an archive to someone or for a monthly backup job.

$DownloadPath = "C:\SPDownloads\Finance"
$ZipPath      = "C:\SPDownloads\Finance_$(Get-Date -Format 'yyyyMMdd').zip"

# ... run your download loop first ...

Compress-Archive -Path "$DownloadPath\*" -DestinationPath $ZipPath -Force
Write-Host "Archive created: $ZipPath" -ForegroundColor Green

Download Files from ALL Document Libraries on a Site

If you want everything on a site (not just one library), loop through all libraries and skip the system ones.

$ExcludeLists = @("Form Templates", "Site Assets", "Style Library",
                  "Site Pages", "Preservation Hold Library", "Customized Reports")

$Libraries = Get-PnPList | Where-Object {
    $_.BaseTemplate -eq 101 -and $_.Hidden -eq $false -and
    $ExcludeLists -notcontains $_.Title
}

foreach ($Lib in $Libraries) {

    $LibFolder = Join-Path "C:\SPDownloads" ($Lib.Title -replace '[\\/:*?"<>|]', '_')
    New-Item -Path $LibFolder -ItemType Directory -Force | Out-Null

    Write-Host "`n=== Library: $($Lib.Title) ===" -ForegroundColor Yellow

    Get-PnPListItem -List $Lib.Title -PageSize 2000 |
    Where-Object { $_.FileSystemObjectType -eq "File" } |
    ForEach-Object {
        Get-PnPFile -Url $_.FieldValues.FileRef -Path $LibFolder `
                    -FileName $_.FieldValues.FileLeafRef -AsFile -Force
    }
}

Add Logging, Retry Logic, and Error Handling (Production-Ready Script)

The scripts above are fine for a one-off task. But if you’re downloading 20,000 files, you need logging and retries – because SharePoint Online will throttle you.

Here’s a hardened version you can use in production.

# ---------- CONFIGURATION ----------
$SiteURL      = "https://contoso.sharepoint.com/sites/Finance"
$ClientId     = "11111111-2222-3333-4444-555555555555"
$LibraryName  = "Documents"
$DownloadPath = "C:\SPDownloads\Finance"
$LogFile      = "C:\SPDownloads\DownloadLog_$(Get-Date -f 'yyyyMMdd_HHmmss').csv"
$MaxRetries   = 3
# -----------------------------------

function Write-Log {
    param($File, $Status, $Message)
    [PSCustomObject]@{
        Timestamp = (Get-Date -Format "yyyy-MM-dd HH:mm:ss")
        File      = $File
        Status    = $Status
        Message   = $Message
    } | Export-Csv -Path $LogFile -NoTypeInformation -Append
}

Connect-PnPOnline -Url $SiteURL -Interactive -ClientId $ClientId

$List       = Get-PnPList -Identity $LibraryName -Includes RootFolder
$LibraryUrl = $List.RootFolder.ServerRelativeUrl

$Items = Get-PnPListItem -List $LibraryName -PageSize 2000 |
         Where-Object { $_.FileSystemObjectType -eq "File" }

$Total = $Items.Count
$Ok = 0; $Fail = 0; $n = 0

foreach ($Item in $Items) {

    $n++
    $FileUrl  = $Item.FieldValues.FileRef
    $FileName = $Item.FieldValues.FileLeafRef

    $RelPath     = $FileUrl.Replace($LibraryUrl, "").Replace("/", "\").TrimStart("\")
    $LocalFile   = Join-Path $DownloadPath $RelPath
    $LocalFolder = Split-Path $LocalFile -Parent

    if (-not (Test-Path $LocalFolder)) {
        New-Item -Path $LocalFolder -ItemType Directory -Force | Out-Null
    }

    Write-Progress -Activity "Downloading from $LibraryName" `
                   -Status "$n / $Total : $FileName" `
                   -PercentComplete (($n / $Total) * 100)

    $Attempt = 0
    $Done = $false

    while (-not $Done -and $Attempt -lt $MaxRetries) {
        $Attempt++
        try {
            Get-PnPFile -Url $FileUrl -Path $LocalFolder -FileName $FileName -AsFile -Force -ErrorAction Stop
            Write-Log -File $FileUrl -Status "Success" -Message "Attempt $Attempt"
            $Ok++; $Done = $true
        }
        catch {
            if ($Attempt -ge $MaxRetries) {
                Write-Log -File $FileUrl -Status "Failed" -Message $_.Exception.Message
                Write-Host "FAILED: $FileName" -ForegroundColor Red
                $Fail++
            }
            else {
                # Exponential back-off for throttling (429 / 503)
                Start-Sleep -Seconds ([math]::Pow(2, $Attempt) * 5)
            }
        }
    }
}

Write-Host "`n===== SUMMARY =====" -ForegroundColor Cyan
Write-Host "Total files : $Total"
Write-Host "Downloaded  : $Ok"   -ForegroundColor Green
Write-Host "Failed      : $Fail" -ForegroundColor Red
Write-Host "Log file    : $LogFile"

Disconnect-PnPOnline

Why the exponential back-off matters: when SharePoint Online throttles you, it returns HTTP 429 or 503. If you keep hammering it, the throttling gets more aggressive. Waiting 10 seconds, then 20, then 40 gives the service time to breathe and dramatically improves your success rate on large jobs.

Handle Long File Paths (The 260-Character Problem)

Windows has a legacy 260-character path limit. SharePoint allows much longer paths, so deeply nested libraries will fail on download with a “path too long” error.

Two fixes:

1. Enable long paths in Windows (requires admin rights and a restart):

New-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem" `
    -Name "LongPathsEnabled" -Value 1 -PropertyType DWORD -Force

2. Use a short root download folder and truncate names in your script:

$MaxPath = 240

if ($LocalFile.Length -gt $MaxPath) {
    $Ext  = [System.IO.Path]::GetExtension($FileName)
    $Base = [System.IO.Path]::GetFileNameWithoutExtension($FileName)
    $Allowed = $MaxPath - $LocalFolder.Length - $Ext.Length - 1
    if ($Allowed -gt 10) {
        $FileName  = $Base.Substring(0, $Allowed) + $Ext
        $LocalFile = Join-Path $LocalFolder $FileName
    }
}

Also strip invalid Windows characters from folder names coming from SharePoint:

$SafeName = $Name -replace '[\\/:*?"<>|]', '_'

Performance Tips for Large Document Libraries

If your library has 50,000+ files, these tips will save you hours.

1. Always use -PageSize. Without it, you’ll hit the 5,000 item list view threshold error. -PageSize 2000 is a good balance.

2. Filter on the server, not in PowerShell. A CAML query returns only matching items. Where-Object downloads all metadata first, then filters – wasteful on large libraries.

3. Request only the fields you need:

$Items = Get-PnPListItem -List $LibraryName -PageSize 2000 `
         -Fields "FileRef", "FileLeafRef", "File_x0020_Size", "Modified"

This alone can cut your metadata retrieval time in half.

4. Download to a local SSD, not a network drive or mapped OneDrive folder. Writing to a synced OneDrive folder means every file gets uploaded again immediately – which is both slow and pointless.

5. Batch by folder. Instead of one script pulling 100,000 files, run separate jobs per top-level folder. If one fails, you don’t restart everything.

6. Don’t run it during business hours. Throttling is far more likely during peak tenant usage. Schedule overnight runs.

Verify Your Download Was Complete

Never assume the download worked. Always compare counts. Below PowerShell script you can run to compare the count.

$SPCount    = (Get-PnPListItem -List $LibraryName -PageSize 2000 |
               Where-Object { $_.FileSystemObjectType -eq "File" }).Count

$LocalCount = (Get-ChildItem -Path $DownloadPath -Recurse -File).Count

Write-Host "SharePoint files : $SPCount"
Write-Host "Local files      : $LocalCount"

if ($SPCount -eq $LocalCount) {
    Write-Host "MATCH - download complete." -ForegroundColor Green
} else {
    Write-Host "MISMATCH - check the log file." -ForegroundColor Red
}

For an even stricter check, compare total byte size:

$SPBytes = (Get-PnPListItem -List $LibraryName -PageSize 2000 |
            Where-Object { $_.FileSystemObjectType -eq "File" } |
            Measure-Object -Property { [int64]$_.FieldValues.File_x0020_Size } -Sum).Sum

$LocalBytes = (Get-ChildItem $DownloadPath -Recurse -File | Measure-Object Length -Sum).Sum

Write-Host "SharePoint: $([math]::Round($SPBytes/1GB,2)) GB"
Write-Host "Local     : $([math]::Round($LocalBytes/1GB,2)) GB"

Schedule the Download to Run Automatically

Once your script works, you can schedule it to run nightly.

Save the script as Download-SPFiles.ps1, switch the connection to certificate-based app-only authentication (interactive login won’t work unattended), and create a scheduled task:

$Action  = New-ScheduledTaskAction -Execute "pwsh.exe" `
           -Argument "-NoProfile -ExecutionPolicy Bypass -File C:\Scripts\Download-SPFiles.ps1"

$Trigger = New-ScheduledTaskTrigger -Daily -At 2:00AM

Register-ScheduledTask -TaskName "SharePoint Nightly Download" `
    -Action $Action -Trigger $Trigger -RunLevel Highest -Description "Downloads files from SharePoint library"

Tip: Combine this with the “modified in the last 7 days” filter so each nightly run only pulls the delta instead of re-downloading everything.

Wrapping Up

In this tutorial, we learned how to download all files from a SharePoint document library using PnP PowerShell.

Here’s my suggested approach:

1. Start with the basic download all files script and confirm your connection works on a small library.
2. Add the filter you actually need – file type, size, date, folder, or metadata.
3. Once it works, upgrade to the production script with logging and retries.
4. Verify with the file count and byte size comparison.
5. Schedule it if this needs to happen regularly.

The single biggest mistake I see people make is skipping the verification step. Always compare the SharePoint count with the local count. A script that “finished successfully” while silently skipping 400 throttled files is worse than no script at all.

Bookmark this page – you’ll find yourself coming back to these snippets more often than you’d expect.

You may also like:

• Delete All Items from a SharePoint List Using PnP PowerShell
• Add SharePoint List Fields From Excel Using PnP PowerShell
• Enable Sensitivity Labels For Microsoft 365 Groups & SharePoint Sites Using PowerShell
• Add Bulk Data from Excel File to SharePoint List Using PnP PowerShell

In this tutorial, you will learn how to use PnP PowerShell to get SharePoint folder permissions, file permissions, and list item permissions. The script exports the results to a CSV file that you can open in Microsoft Excel for review, auditing, or compliance reporting.

The report includes:

• Folder, file, list item, or library name
• Direct URL to the SharePoint object
• Whether the object has unique permissions
• User or SharePoint group name
• Email address
• Principal type
• Assigned permission levels
• Whether access was granted directly or through a SharePoint group

Prerequisites

Before running the script, make sure you have completed the following requirements:

• Install the latest PnP PowerShell module.
• Register a Microsoft Entra ID application and copy its client ID.
• Ensure that the signed-in account has sufficient access to read permissions from the target SharePoint site, library, folders, and files.
• Create a local folder to the CSV permissions report. Note: The output file is a CSV file. You can open it directly in Microsoft Excel after the script finishes.

PnP PowerShell Script to Get SharePoint Folder Permissions

The following PnP PowerShell script retrieves permissions from a SharePoint document library. It can scan the library itself and, when enabled, every folder, subfolder, file, and list item in that library.

Keep the script unchanged and update the configuration values at the beginning.

$SiteURL="https://.sharepoint.com/sites/RetailManagementSite"
$ListName = "Employee Satisfaction Survey PDF Files"
$ReportFile="D:\Temp Folder\Employee Satisfaction Survey PDF Files.csv"

If (Test-Path $ReportFile) {
    Remove-Item $ReportFile
}

Function Get-LibraryPermissions([Microsoft.SharePoint.Client.SecurableObject] $Object) {
    Switch($Object.TypedObject.ToString()) {
        "Microsoft.SharePoint.Client.ListItem" {
            If($Object.FileSystemObjectType -eq "Folder") {
                $ObjectType = "Folder"

                #Get the URL of the Folder
                $Folder = Get-PnPProperty -ClientObject $Object -Property Folder
                $ObjectTitle = $Object.Folder.Name
                $ObjectURL = ("{0}{1}" -f $Web.Url.Replace($Web.ServerRelativeUrl,''),$Object.Folder.ServerRelativeUrl)
            }
            Else {
                Get-PnPProperty -ClientObject $Object -Property File, ParentList

                If($Object.File.Name -ne $Null) {
                    $ObjectType = "File"
                    $ObjectTitle = $Object.File.Name
                    $ObjectURL = ("{0}{1}" -f $Web.Url.Replace($Web.ServerRelativeUrl,''),$Object.File.ServerRelativeUrl)
                }
                else {
                    $ObjectType = "List Item"
                    $ObjectTitle = $Object["Title"]

                    #Get the URL of the List Item
                    $DefaultDisplayFormUrl = Get-PnPProperty -ClientObject $Object.ParentList -Property DefaultDisplayFormUrl
                    $ObjectURL = ("{0}{1}?ID={2}" -f $Web.Url.Replace($Web.ServerRelativeUrl,''), $DefaultDisplayFormUrl,$Object.ID)
                }
            }
        }

        Default {
            $ObjectType = "List or Library"
            $ObjectTitle = $Object.Title

            #Get the URL of the List or Library
            $RootFolder = Get-PnPProperty -ClientObject $Object -Property RootFolder
            $ObjectURL = ("{0}{1}" -f $Web.Url.Replace($Web.ServerRelativeUrl,''), $RootFolder.ServerRelativeUrl)
        }
    }

    Get-PnPProperty -ClientObject $Object -Property HasUniqueRoleAssignments, RoleAssignments

    $HasUniquePermissions = $Object.HasUniqueRoleAssignments
    $PermissionCollection = @()

    Foreach($RoleAssignment in $Object.RoleAssignments) {
        Get-PnPProperty -ClientObject $RoleAssignment -Property RoleDefinitionBindings, Member

        $PermissionType = $RoleAssignment.Member.PrincipalType
        $PermissionLevels = $RoleAssignment.RoleDefinitionBindings | Select -ExpandProperty Name
        $PermissionLevels = ($PermissionLevels | Where { $_ -ne "Limited Access"}) -join ","

        If($PermissionLevels.Length -eq 0) {
            Continue
        }

        If($PermissionType -eq "SharePointGroup") {
            $GroupMembers = Get-PnPGroupMember -Identity $RoleAssignment.Member.LoginName

            If($GroupMembers.count -eq 0) {
                Continue
            }

            $GroupUsers = ($GroupMembers | Select -ExpandProperty Title) -join "; "

            $Permissions = New-Object PSObject
            $Permissions | Add-Member NoteProperty Object($ObjectType)
            $Permissions | Add-Member NoteProperty Title($ObjectTitle)
            $Permissions | Add-Member NoteProperty URL($ObjectURL)
            $Permissions | Add-Member NoteProperty HasUniquePermissions($HasUniquePermissions)
            $Permissions | Add-Member NoteProperty Users($GroupUsers)
            $Permissions | Add-Member NoteProperty Email($RoleAssignment.Member.Email)
            $Permissions | Add-Member NoteProperty Type($PermissionType)
            $Permissions | Add-Member NoteProperty Permissions($PermissionLevels)
            $Permissions | Add-Member NoteProperty GrantedThrough("SharePoint Group: $($RoleAssignment.Member.LoginName)")

            $PermissionCollection += $Permissions
        }
        Else {
            $Permissions = New-Object PSObject
            $Permissions | Add-Member NoteProperty Object($ObjectType)
            $Permissions | Add-Member NoteProperty Title($ObjectTitle)
            $Permissions | Add-Member NoteProperty URL($ObjectURL)
            $Permissions | Add-Member NoteProperty HasUniquePermissions($HasUniquePermissions)
            $Permissions | Add-Member NoteProperty Users($RoleAssignment.Member.Title)
            $Permissions | Add-Member NoteProperty Email($RoleAssignment.Member.Email)
            $Permissions | Add-Member NoteProperty Type($PermissionType)
            $Permissions | Add-Member NoteProperty Permissions($PermissionLevels)
            $Permissions | Add-Member NoteProperty GrantedThrough("Direct Permissions")

            $PermissionCollection += $Permissions
        }
    }

    $PermissionCollection | Export-CSV $ReportFile -NoTypeInformation -Append
}

Function Generate-LibraryPermissionsReport() {
    [cmdletbinding()]

    Param (
        [Parameter(Mandatory=$false)]
        [String] $SiteURL,

        [Parameter(Mandatory=$false)]
        [String] $ListName,

        [Parameter(Mandatory=$false)]
        [String] $ReportFile,

        [Parameter(Mandatory=$false)]
        [switch] $ScanItemLevel,

        [Parameter(Mandatory=$false)]
        [switch] $IncludeInheritedPermissions
    )

    Try {
        Function Get-PnPListItemsPermission([Microsoft.SharePoint.Client.List]$List) {
            Write-host -f Yellow "`t `t Getting Permissions of List Items in the List:"$List.Title

            $ListItems = Get-PnPListItem -List $List -PageSize 500
            $ItemCounter = 0

            ForEach($ListItem in $ListItems) {
                If($IncludeInheritedPermissions) {
                    Get-LibraryPermissions -Object $ListItem
                }
                Else {
                    $HasUniquePermissions = Get-PnPProperty -ClientObject $ListItem -Property HasUniqueRoleAssignments

                    If($HasUniquePermissions -eq $True) {
                        Get-LibraryPermissions -Object $ListItem
                    }
                }

                $ItemCounter++

                Write-Progress -PercentComplete ($ItemCounter / ($List.ItemCount) * 100) `
                    -Activity "Processing Items $ItemCounter of $($List.ItemCount)" `
                    -Status "Searching Unique Permissions in List Items of '$($List.Title)'"
            }
        }

        $List = Get-PnpList -Identity $ListName -Includes RoleAssignments

        Write-host -f Yellow "Getting Permissions of the List '$ListName'..."

        Get-LibraryPermissions -Object $List

        If($ScanItemLevel) {
            Get-PnPListItemsPermission -List $List
        }

        Write-host -f Green "`t List Permission Report Generated Successfully!"
    }
    Catch {
        write-host -f Red "Error Generating List Permission Report!"
        $_.Exception.Message
    }
}

Connect-PnPOnline -URL $SiteURL -ClientId "Provide your client ID" -Interactive

$Web = Get-PnPWeb

Generate-LibraryPermissionsReport -SiteURL $SiteURL -ListName $ListName -ReportFile $ReportFile -ScanItemLevel

Update the Script Variables

Before you run the script, update these values with information from your SharePoint environment.

$SiteURL="https://.sharepoint.com/sites/RetailManagementSite"
$ListName = "Employee Satisfaction Survey PDF Files"
$ReportFile="D:\Temp Folder\Employee Satisfaction Survey PDF Files.csv"

• $SiteURL: Enter the URL of the SharePoint Online site that contains the target library.
• $ListName: Enter the display name of the SharePoint document library or list.
• $ReportFile: Enter the complete local path and file name for the CSV report.

For example:

$SiteURL = "https://contoso.sharepoint.com/sites/HR"
$ListName = "Employee Documents"
$ReportFile = "C:\Reports\SharePointFolderPermissions.csv"

If the report file already exists at the selected location, the script removes it before generating a new report.

If (Test-Path $ReportFile) {
    Remove-Item $ReportFile
}

Add Your Microsoft Entra ID Client ID

Locate the following line in the script:

Connect-PnPOnline -URL $SiteURL -ClientId "Provide your client ID" -Interactive

Replace "Provide your client ID" with the application or client ID from your Microsoft Entra ID app registration.

Connect-PnPOnline -URL $SiteURL -ClientId "YOUR-CLIENT-ID" -Interactive

The -Interactive parameter opens the Microsoft sign-in window. Sign in with an account that has permission to access the SharePoint site and inspect the library permissions.

Run the SharePoint Permission Report Script

Save the script as a .ps1 file, such as:

Get-SharePoint-Folder-Permissions.ps1

Open PowerShell, navigate to the folder where you saved the script, and run it.

The script connects to your SharePoint Online site, retrieves permissions from the selected library, scans files and folders, and exports the details to the configured CSV file.

When the script completes successfully, you will see the following message:

List Permission Report Generated Successfully!

Open the generated CSV file in Microsoft Excel to review the SharePoint folder permissions and file permissions.

Understanding the Permission Report

The exported CSV report provides a detailed view of permission assignments across the selected SharePoint document library.

This report is particularly useful for identifying folders and files with broken permission inheritance. You can also use it to detect unexpected direct permissions, external access, or users who have access through SharePoint groups.

How the Get-LibraryPermissions Function Works

The Get-LibraryPermissions function is responsible for retrieving permission information for a SharePoint object.

It works with the following SharePoint object types:

• SharePoint list or document library
• Folder
• File
• List item

The function first identifies the object type and retrieves its title and URL. It then checks whether the object has unique role assignments by reading the HasUniqueRoleAssignments property.

Get-PnPProperty -ClientObject $Object -Property HasUniqueRoleAssignments, RoleAssignments

If an object inherits permissions, the HasUniquePermissions value in the report is set to False. If permission inheritance has been broken and the object has its own assignments, the value is set to True.

The function then loops through each role assignment, retrieves the assigned permission levels, and excludes the Limited Access role from the report. This keeps the output focused on meaningful permissions such as Read, Edit, Contribute, Design, or Full Control.

For SharePoint groups, the script retrieves the group members and adds them to the report. For individual users, it records direct permissions and identifies them as Direct Permissions in the GrantedThrough column.

How the Generate-LibraryPermissionsReport Function Works

The Generate-LibraryPermissionsReport function controls the overall permission-reporting process.

It accepts the following parameters:

$SiteURL
$ListName
$ReportFile
$ScanItemLevel
$IncludeInheritedPermissions

The function first retrieves the selected SharePoint list or document library.

$List = Get-PnpList -Identity $ListName -Includes RoleAssignments

It then retrieves the library-level permissions by calling the Get-LibraryPermissions function.

Get-LibraryPermissions -Object $List

When you use the -ScanItemLevel switch, the script also scans every item in the library. This includes folders, subfolders, files, and list items.

Generate-LibraryPermissionsReport -SiteURL $SiteURL -ListName $ListName -ReportFile $ReportFile -ScanItemLevel

For large document libraries, scanning every item can take time because the script must inspect each folder and file individually. The progress bar in PowerShell shows the number of items processed during the scan.

Include Inherited Permissions

By default, the script focuses on items with unique permissions when scanning item-level permissions. This is helpful when you want to identify folders and files where inheritance has been broken.

To include inherited permissions in the report as well, run the command with the -IncludeInheritedPermissions switch.

Generate-LibraryPermissionsReport `
    -SiteURL $SiteURL `
    -ListName $ListName `
    -ReportFile $ReportFile `
    -ScanItemLevel `
    -IncludeInheritedPermissions

Use this option when you need a complete SharePoint permission inventory. Keep in mind that the CSV file can become large when the document library contains many files and folders.

Access Denied Error in PnP PowerShell

While running the script, you may encounter the following error:

Access is denied. (Exception from HRESULT: 0x80070005 (E_ACCESSDENIED))

You can see the exact error message in the screenshot below.

This error usually occurs when the account used to connect through Connect-PnPOnline does not have sufficient access to read permissions from the SharePoint site, document library, folders, or files.

To resolve the issue, sign in with an account that has the required permissions. In many tenant-wide administrative scenarios, assigning the SharePoint Administrator role to the account can resolve the error.

You can assign the SharePoint Administrator role from the Microsoft 365 admin center:

1. Open the Microsoft 365 admin center.
2. Select Users and then Active users.
3. Choose the user account.
4. Open the Roles section.
5. Select Admin center access.
6. Assign the SharePoint Administrator role.
7. Save the changes.

Here is a screenshot for your reference.

After the role assignment has taken effect, run the PnP PowerShell script again.

Important Notes

• The account running the script must have access to the site and the objects being scanned.
• The script can retrieve permissions for document libraries as well as SharePoint lists.
• Use -ScanItemLevel to include folders, subfolders, files, and list items.
• Use -IncludeInheritedPermissions when you need both unique and inherited permission assignments.
• The report excludes Limited Access permissions to make the output easier to review.
• For very large libraries, run the report during off-peak hours and allow enough time for the scan to complete.
• Review the CSV file in Excel and filter the HasUniquePermissions column to quickly find files and folders with broken permission inheritance.

Conclusion

Using PnP PowerShell is an efficient way to audit SharePoint folder permissions, file permissions, and item-level permissions in a SharePoint Online document library. The script gives you an exportable CSV report that clearly shows users, groups, permission levels, direct assignments, inherited access, and unique permissions.

This approach is useful for SharePoint permission audits, compliance reviews, security assessments, migration planning, and routine administration of document libraries with complex folder structures.

You may also like the following tutorials:

• Add More Than 5000 Items to a SharePoint Online List Using PnP PowerShell
• Create Document Library in SharePoint Using PnP PowerShell (With Multiple Folders)
• Delete All Items from a SharePoint List Using PnP PowerShell
• Enable Sensitivity Labels For Microsoft 365 Groups & SharePoint Sites Using PowerShell

That process changes quickly when you create a report in Power BI Desktop. You can connect to your Excel or SharePoint data, clean it once, build interactive visuals, and give managers a report they can filter themselves.

This step-by-step Power BI tutorial uses a retail sales dashboard example and covers the full process, from loading data through publishing and sharing.

Before You Create a Report in Power BI Desktop

Before you create a report in Power BI Desktop, prepare data that supports analysis. For this example, assume a mid-sized retail company tracks sales in an Excel workbook or a SharePoint Online list.

The sales data should include fields such as:

• Order Date
• Order ID
• Product Name
• Product Category
• Region
• Salesperson
• Quantity
• Sales Amount
• Cost Amount

Each row should represent one transaction. This structure matters because Power BI Desktop works best when every record has a clear business meaning. Avoid merged cells, blank header rows, totals inside the source data, and inconsistent date formats.

For Excel, convert your range into an Excel Table before connecting. Click inside the data, select Insert > Table, and give it a meaningful name such as Sales. A proper table expands when new rows arrive, which makes refreshes far more reliable.

For SharePoint, keep column names simple and clear. Use a Number column for quantity, Currency for sales values, and Date and Time for order dates. If you are starting with SharePoint lists, review this guide on how to create and manage a SharePoint list.

Pro Tip: I have found that most report issues begin in the source data, not the visual. Spend a few minutes cleaning headers and data types before loading anything into Power BI.

Create a Report in Power BI Desktop From Excel

Excel remains a common starting point for small business reporting. It works well when a team stores transactional data in a controlled workbook and updates it regularly.

Connect to the Excel workbook

Open Power BI Desktop and select Get data from the Home tab.

1. Select Excel workbook.
2. Browse to your workbook and select Open.
3. In the Navigator window, select the Sales table.
4. Choose Transform Data instead of loading immediately.

Choose Transform Data because it opens Power Query Editor. Power Query is the data preparation area in Power BI Desktop. You use it to clean, rename, filter, split, and format columns before the data enters your report.

If your sales file contains extra columns such as Notes, Internal Comments, or Created By, remove them now. Smaller tables refresh faster and make the data model easier to understand.

Clean the sales data in Power Query

Inside Power Query Editor, check each column’s data type. Power BI may guess correctly, but do not rely on that guess.

For the retail sales example, use these data types:

• Order Date: Date
• Order ID: Text
• Product Name: Text
• Region: Text
• Quantity: Whole Number
• Sales Amount: Fixed Decimal Number or Currency
• Cost Amount: Fixed Decimal Number or Currency

To change a type, select the column, choose the type icon beside the column name, and select the correct option. This step is important because Power BI calculations depend on data types. A sales amount stored as text will not calculate correctly in a measure.

Rename unclear columns while you are here. For example, rename Amt to Sales Amount and ProdNm to Product Name. Clear names make report development easier, especially when several people maintain the file.

If you need to add or modify fields during data preparation, see these practical Power Query column examples.

When the table looks clean, click Close & Apply. Power BI loads the data into the report.

Create a Report in Power BI Desktop From SharePoint

A SharePoint Online list works well when multiple people enter or update operational data. For example, a sales operations team may maintain product, vendor, inventory, or order status information in SharePoint.

Connect to a SharePoint Online list

In Power BI Desktop, select Home > Get data > More.

1. Select Online Services.
2. Choose SharePoint Online List.
3. Click Connect.
4. Enter the SharePoint site URL, not the full list URL.
5. Sign in with an account that has access to the site.
6. Select the required list in the Navigator window.
7. Click Transform Data.

Power BI displays available lists from that SharePoint site. Select only the lists needed for the report. For a sales dashboard, you may choose a Sales Orders list, a Products list, and a Regions list.

Expand lookup and person columns

SharePoint lookup, person, and choice columns often appear as Record values in Power Query. You must expand them before building visuals.

Select the expand icon on the column header. Then choose only the subfields you need, such as Value, Title, DisplayName, or Email.

For example, if the Product field is a SharePoint lookup column, expand it and select the product name. If you leave it as a record, your chart cannot display a readable product label.

You should also remove SharePoint system fields that do not help the report, such as Version, Attachments, Content Type, or Edit links. Retain fields only when users need them for reporting or filtering.

Validate the SharePoint data types

SharePoint connectors often bring fields into Power Query with the Any type. Correct them before loading.

Set:

• Sales dates to Date
• Quantity to Whole Number
• Sales values to Currency
• Product and region names to Text

If dates look wrong after loading, use this guide to convert yyyymmdd values to proper dates in Power BI.

Build a Simple Data Model

A data model connects related tables so Power BI can filter and calculate across them. For a beginner report built from one Excel table, Power BI may only have one table. That is fine for an initial dashboard.

For a more reliable sales dashboard, split your model into a fact table and supporting dimension tables.

• Sales: The fact table that contains transactions and numeric values.
• Product: A dimension table with product name, category, and brand.
• Region: A dimension table with region and territory details.
• Date: A dimension table that supports monthly, quarterly, and yearly analysis.

Open Model view from the left navigation. Create one-to-many relationships from each dimension to the Sales table. For example, Product[Product ID] should connect to Sales[Product ID].

A one-to-many relationship means one product can appear in many sales transactions. This design is called a star schema because the Sales table sits in the middle and the lookup tables surround it.

Avoid linking every table to every other table. That creates confusing filter paths and incorrect totals. If you notice blank values in visuals, inspect your keys and relationships using this guide on filtering blank values in Power BI.

Add a Date Table for Time Analysis

A proper Date table helps you compare months, quarters, and years. It also supports time intelligence calculations such as last year’s sales.

Create a new table by selecting Modeling > New table. Add this DAX formula:

Date =
CALENDAR(
    MIN(Sales[Order Date]),
    MAX(Sales[Order Date])
)

This formula creates one row for every date between the earliest and latest order date in your Sales table.

Next, add useful date columns:

Year = YEAR('Date'[Date])

Month Number = MONTH('Date'[Date])

Month Name = FORMAT('Date'[Date], "MMMM")

Year Month = FORMAT('Date'[Date], "YYYY MMM")

Then select the Date table, choose Table tools, and click Mark as date table. Select the Date column when Power BI asks for the date field.

Marking the table tells Power BI that this table controls calendar logic. Create a relationship from Date[Date] to Sales[Order Date].

For a deeper walkthrough, read how to create a calendar table using the DAX CALENDAR function.

Create DAX Measures for Your KPIs

A measure is a calculation that responds to filters, slicers, and visuals. Measures work better than calculated columns for totals, averages, and KPIs because Power BI calculates them when users interact with the report.

Right-click the Sales table and select New measure.

Create the main sales measure:

Total Sales =
SUM(Sales[Sales Amount])

This measure adds the Sales Amount values in the current filter context. If a user chooses the West region in a slicer, it returns only West region sales.

Create a quantity measure:

Total Quantity =
SUM(Sales[Quantity])

Create a profit measure:

Total Profit =
SUM(Sales[Sales Amount]) - SUM(Sales[Cost Amount])

Create last year sales:

Sales LY =
CALCULATE(
    [Total Sales],
    SAMEPERIODLASTYEAR('Date'[Date])
)

The CALCULATE function changes the filter context. SAMEPERIODLASTYEAR shifts the selected date range back one year. If the visual shows March 2026 sales, this measure returns March 2025 sales.

Create year-over-year growth:

Sales YoY % =
DIVIDE(
    [Total Sales] - [Sales LY],
    [Sales LY]
)

The DIVIDE function avoids errors when last year’s sales equal zero. Format this measure as a percentage.

Pro Tip: In my experience, a report becomes easier to maintain when all core calculations are measures. Avoid creating a new calculated column just to show a total on a card.

Design the Sales Dashboard

Now move to Report view. A strong report answers a business question without making users hunt for data.

For this example, create one page called Sales Overview.

Add KPI cards

Use Card visuals at the top of the report. Add:

• Total Sales
• Total Profit
• Total Quantity
• Sales YoY %

Cards give managers a quick view of the numbers that matter. Keep four or fewer cards in one row to avoid clutter.

Add a monthly sales trend

Add a Line chart.

• X-axis: Date[Year Month]
• Y-axis: Total Sales

Sort the axis by a real date field or month number. Alphabetical month names create the wrong sequence, such as April, August, December, and February.

A line chart shows movement over time. It helps a manager spot a slow month, seasonal demand, or sudden growth.

Add sales by region and product

Add a Clustered bar chart.

• Y-axis: Region[Region Name]
• X-axis: Total Sales

Then add another bar chart:

• Y-axis: Product[Product Category]
• X-axis: Total Sales

Bar charts make comparisons easy. Use them for categories, regions, salespeople, or product lines. Sort each chart by Total Sales in descending order so the highest performer appears first.

Add slicers for interaction

A Slicer lets users filter report visuals without editing the report.

Add slicers for:

• Year
• Region
• Product Category
• Salesperson

Use a dropdown design when your slicer has many choices. It saves space and keeps the dashboard clean. This detailed guide explains how to add a dropdown slicer in Power BI.

Make sure every visual responds to the slicers. Select a slicer, go to Format > Edit interactions, and confirm that it filters the correct charts.

Publish and Share the Report

Save the file as a .pbix file first. Use a meaningful name such as Retail-Sales-Dashboard.pbix.

To publish, select Publish from the Home ribbon and sign in to your Power BI account. Choose a workspace, which is a shared area in Power BI Service where teams store reports, datasets, dashboards, and apps.

Choose a workspace based on the audience:

• Use My workspace for personal testing.
• Use a team workspace for department reports.
• Use a controlled workspace for production reports.

After publishing, open the report in Power BI Service. Check the layout, refresh the data, and configure access for the correct users.

If your report uses SharePoint Online lists or files stored in SharePoint, scheduled refresh usually works without an on-premises gateway. If the Excel file sits on your laptop or a local network drive, you may need a gateway before Power BI Service can refresh it.

Things to Consider

• Use a star schema: Keep transaction data in a central Sales table and connect it to dimensions such as Date, Product, and Region. This model produces more reliable filtering and calculations.
• Use measures for KPIs: Create DAX measures for sales, profit, and growth rates. Measures react to slicers, while calculated columns increase model size.
• Check data types early: Set dates, currency values, and quantities correctly in Power Query before building visuals or writing DAX.
• Avoid too many visuals: A dashboard should answer key questions quickly. Use a few meaningful cards, charts, and slicers instead of filling every empty space.
• Protect sensitive data: Use Row-Level Security when regional managers should only view their own region’s data.
• Test refresh before sharing: Refresh the report in Power BI Service after publishing. Check credentials, source paths, and list permissions before users depend on it.

Frequently Asked Questions

Report in Power BI Desktop becomes straightforward when you begin with clean Excel or SharePoint data, build a simple data model, and use measures for your business KPIs. Start with one focused sales dashboard, validate the numbers, and improve the design as your users ask better questions. I hope you found this article helpful.

You May Also Like

• Power BI date slicer only shows dates with data
• Power BI Date Slicer by Month
• How to sort a Power BI slicer by measure
• Power BI DAX MIN date function with examples
• Export a Power BI report to Excel
• Power BI Free vs Pro vs Premium comparison