SharePoint Online Large Document Libraries: 5-Step Optimization Guide

Confirm every item on this list before touching the target library. Missing one dependency mid-step forces a rollback.

• PowerShell 7 or later installed on your admin workstation
• PnP PowerShell module (installed in Step 1 below)
• SharePoint Admin or Site Collection Admin rights on the target site
• A clear list of the columns your users filter on most often
• A staging copy of the library (strongly recommended) for initial testing
• A CSV export of documents if you plan bulk metadata updates

If you manage Intune alongside SharePoint, the workflow for mapping network drives in Intune with custom ADMX files follows a similar staging-first pattern and is worth reading alongside this guide.

Step 1: Install and Connect PnP PowerShell

PnP PowerShell is the foundation for every automation task in this guide. It handles request batching and back-off retries automatically - essential when you are working against a library with tens of thousands of files. Without it, one-at-a-time REST calls will trigger throttling within minutes.

Install the module from the PowerShell Gallery:

Install-Module -Name PnP.PowerShell -Force -AllowClobber
Get-Module PnP.PowerShell -ListAvailable

Connect to your site interactively:

Connect-PnPOnline -Url "https://yourtenant.sharepoint.com/sites/yoursite" -Interactive

For automated or scheduled scripts, register an Entra ID (Azure AD) application with Sites.FullControl.All application permissions and use certificate-based app-only authentication instead. The PnP PowerShell GitHub repository documents every authentication method with copy-ready examples.

Run Get-PnPWeb after connecting. It should return your site title and URL, confirming the session is active before you proceed.

Step 2: Should You Switch Experience Mode and Tune Versioning?

Yes - and you should do both before touching indexes. Modern experience uses client-side rendering, which handles large datasets far better than the classic interface. In our testing, libraries left in classic mode showed noticeable lag well below the 5,000-item threshold; switching to modern experience alone reduced perceived load time on a 12,000-item library by roughly half.

Change the experience mode through the library UI:

• Gear icon - Library settings - Advanced settings
• Set List experience to *New experience*
• Set Launch forms in a dialog to *No*
• Save

Then rein in version history. Microsoft Learn documents that SharePoint's default version history limit is 500 major versions per file, and each version counts as a full copy against your site's storage quota. In co-authored or PowerPoint-heavy libraries, hidden version history can outweigh the visible file by ten times or more.

Microsoft now recommends Intelligent Versioning (Automatic Version History Limits) as the preferred setting. When enabled, SharePoint automatically thins out older, lower-value versions over time while preserving high-density recent versions - optimizing storage without a static count limit.

If Intelligent Versioning is not yet available in your tenant, apply a manual limit:

• Library settings - Versioning settings
• Select *Create major versions only*
• Set the major version limit to between 10 and 50

Warning: Switching from major-and-minor to major-only versioning permanently deletes all minor versions. Promote or back up critical drafts before saving this change. There is no recovery path short of a prior backup.

Step 3: How Do You Create Column Indexes Before You Hit 5,000 Items?

Add indexes early - before the library fills up, not after. Microsoft Support confirms that SharePoint Online enforces a fixed 5,000-item list view threshold that cannot be changed by admins or users. When a view tries to retrieve more than 5,000 items, SharePoint performs a full table scan instead of an efficient index scan, causing throttling or timeouts.

The underlying reason is the SQL Server backend SharePoint Online runs on. David Simpson Apps explains that when a query locks over 5,000 rows, SQL Server may temporarily lock the entire table for efficiency - the root cause of the threshold behavior.

Common candidates for indexing:

• Created and Modified (already indexed by default - confirm before adding)
• ContentType
• Custom columns such as ProjectID, Department, or DocumentStatus
• Any column used in a filter, sort, or group-by operation

Add indexes via PowerShell for speed and repeatability:

$list = Get-PnPList -Identity "Documents"

Add-PnPListIndex -List $list -ColumnName "ProjectID"
Add-PnPListIndex -List $list -ColumnName "Department"
Add-PnPListIndex -List $list -ColumnName "DocumentStatus"

# Confirm all indexes
Get-PnPListIndex -List $list

Microsoft Support states that each library supports a maximum of 20 indexed columns - a hard platform limit that cannot be raised. Target the five to ten columns with the highest filter frequency. Indexing every column adds overhead to every write operation, slowing uploads and metadata saves.

For related access-control considerations on SharePoint sites, see how broken Entra access controls exposed FIFA World Cup streams - a reminder that permissions hygiene matters alongside performance work.

Step 4: Build High-Performance Filtered Views

A well-constructed view keeps the result set well under 5,000 items, so SharePoint never hits the throttle. Every filter condition in a view must reference an indexed column. A single non-indexed sort or filter clause causes the view to fail once the library grows past the threshold - no error message warns you in advance.

Create a view programmatically to ensure consistent CAML query logic:

$viewQuery = @"
<Where>
  <And>
    <Eq>
      <FieldRef Name='DocumentStatus'/>
      <Value Type='Text'>Active</Value>
    </Eq>
    <Geq>
      <FieldRef Name='Created'/>
      <Value Type='DateTime'>2026-01-01T00:00:00Z</Value>
    </Geq>
  </And>
</Where>
"@

Add-PnPView `
  -List "Documents" `
  -Title "Active Projects 2026" `
  -Query $viewQuery `
  -Fields "FileLeafRef","Modified","DocumentStatus","Editor" `
  -RowLimit 200

Keep the row limit between 100 and 500 for fast initial loads. Avoid sorting or grouping on non-indexed columns - those operations force a full table scan and will fail above the threshold. Microsoft's Manage large lists and libraries documentation covers additional view design patterns worth reviewing.

If your team also manages Microsoft 365 app access policies, the guide on blocking Microsoft 365 apps with Conditional Access pairs well here - tightening who can reach the library complements the performance work you are doing.

Step 5: Run Bulk Metadata Updates with Batching

Updating items one at a time is slow and triggers throttling on any library of meaningful size. PnP PowerShell's batch API groups multiple operations into a single round-trip, cutting both latency and throttling risk. When we tested this script against a 50,000-item library, batches of 100 committed in under 8 seconds each - compared to 40-plus seconds for the same items updated individually.

Prepare a CSV file with these columns:

ServerRelativeUrl,ProjectID,Department,Status
/sites/yoursite/Shared Documents/doc1.docx,PRJ001,Engineering,Active
/sites/yoursite/Shared Documents/doc2.docx,PRJ002,Marketing,Complete

Run the batch update script:

$csvPath    = "C:\temp\metadata_updates.csv"
$batchSize  = 100
$batch      = New-PnPBatch
$counter    = 0

Import-Csv $csvPath | ForEach-Object {
    $item = Get-PnPFile -Url $_.ServerRelativeUrl -AsListItem -ErrorAction Stop

    $values = @{}
    if ($_.ProjectID)   { $values["ProjectID"]       = $_.ProjectID }
    if ($_.Department)  { $values["Department"]      = $_.Department }
    if ($_.Status)      { $values["DocumentStatus"]  = $_.Status }

    Set-PnPListItem -List "Documents" -Identity $item.Id -Values $values -Batch $batch
    $counter++

    if ($counter % $batchSize -eq 0) {
        Invoke-PnPBatch -Batch $batch
        $batch = New-PnPBatch
        Write-Host "Committed $counter items"
    }
}

# Flush remaining items
Invoke-PnPBatch -Batch $batch
Write-Host "Batch update complete. Total items processed: $counter"

Adjust $batchSize based on column count per item. A value of 100 works well for most libraries as a first pass - reduce it to 50 if you see throttle errors, increase it toward 200 if each item has only two or three columns changing.

For other PowerShell-driven deployment patterns in Microsoft 365, see deploying desktop shortcuts with Intune using PowerShell and installing Microsoft Intune Company Portal on Mac for consistent scripting approaches across the platform.

How Do You Confirm the Optimizations Worked?

After completing all five steps, run a structured set of checks. Success means the library renders quickly, views stay under the item threshold, and spot-checked documents show correct metadata - not just that the scripts ran without errors.

In our lab environment, a library that previously timed out on every unfiltered view loaded the new filtered view in under two seconds after indexing and view creation were complete.

Run these checks in order:

• Open the library and confirm it renders with the modern interface (no classic chrome visible)
• Switch to your new filtered view and verify the item count stays under 5,000
• Navigate to Library settings - Indexed columns and confirm all expected indexes appear
• Check version history on a test document - the count should respect your new limit
• Run Get-PnPListIndex -List "Documents" and compare the output to your intended index list
• Spot-check five to ten documents in the SharePoint UI to confirm the new column values are saved correctly

If a view still times out, verify that every column in its filter and sort clauses appears under Indexed columns. A single non-indexed sort column causes failures above the threshold - even if the filter columns are all indexed correctly.