Teams combines collaboration, Microsoft 365 Groups, SharePoint sites, memberships, and lifecycle management. That creates many practical problems for administrators.
Articles TBD:
How to Find Teams With No Owners or Inactive Members
What Happens to the SharePoint Site When a Team Is Archived?
How to Report on Teams, Channels, Owners, and Memberships
How to Find Orphaned Microsoft 365 Groups
How to Design a Microsoft Teams Expiration and Renewal Process
How to Audit External Users Across Teams and SharePoint
Microsoft is expanding agent management, including controls for agent availability, access, and usage. SharePoint administrators now have new agent-related governance capabilities to understand.
Articles TBD:
How to Inventory Copilot Agents Across a Microsoft 365 Tenant
How SharePoint Permissions Affect AI Agent Responses
Who Can Create and Publish Copilot Agents? An Administrator’s Guide
How to Audit Which Agents Can Access Your SharePoint Content
SharePoint Agents vs. Copilot Studio Agents: What Administrators Need to Know
Organizations need to make existing content safe and useful for AI without accidentally exposing sensitive information. Microsoft explicitly recommends addressing oversharing, inactive sites, and governance before relying on Copilot.
Audience: Microsoft 365 administrators, architects, security teams.
Articles TBD:
How to Find SharePoint Sites That Are Overshared Before Enabling Copilot
SharePoint Copilot Readiness Checklist for Enterprise Administrators
How to Identify and Remediate Sites With Broken Permission Governance
Restricted Content Discovery vs. Restricted Access Control: What’s the Difference?
How to Build a SharePoint Copilot Readiness Report With PowerShell
When a user leaves an organization, their account is usually deleted from Microsoft Entra ID. However, SharePoint often keeps a record of that user in its own databases. These records are commonly called orphaned users. Most of the time they do not cause any problems. But when the same user principal name (UPN) is later assigned to a new account, these orphaned records can cause the well-known User ID Mismatch issue. In this article, we’ll look at what orphaned users are, why they exist, how they are related to User ID Mismatch, and what SharePoint administrators can do about them.
Overview
An orphaned user in SharePoint is generally understood as a user whose record still exists in a SharePoint, even though the corresponding Microsoft Entra ID account no longer exists in directory.
Orphaned user records are not necessarily errors. SharePoint maintains its own databases at every site and caches user’s data so that it can preserve historical context, such as who created or modified a document. However, these records can become operationally significant when an organization creates a new Entra ID account using the same User Principal Name (or UPN), as a previously deleted account.
This can produce a SharePoint user ID mismatch:
The old and new accounts have the same UPN, but different “internal” object IDs.
SharePoint keeps the old UPN and still associates the UPN with the old identity.
The newly created user receives permissions, but cannot access content (user id mismatch)
This article explains:
What orphaned SharePoint users are.
Why SharePoint retains them.
How they contribute to user ID mismatch.
Why fixing one affected site does not solve the tenant-wide problem.
How remediation strategies differ by tenant size, tenant age, and employee turnover.
How to approach the problem using cleanup, ticket prevention, and offboarding controls.
What Is an Orphaned User in SharePoint?
SharePoint maintains information about users who have interacted with or received permissions to a site collection. This information is stored in the site collection’s User Information List, commonly referred to as the UIL (it’s a hidden list in every SharePoint site collection). When a person visits a site or is otherwise resolved as a user, SharePoint caches information about that identity in this list. Deleting the corresponding account from Microsoft 365 or Entra ID does not necessarily remove the entry from each SharePoint UIL.
The resulting record is commonly called an “Orphaned user” or “Stale user” or “Legacy user” or “Orphaned SharePoint identity”. “Orphaned user” is a useful administrative term, although Microsoft documentation more frequently uses terms such as legacy user account, outdated user account, or an old entry in the UIL.
Why does SharePoint retain the user?
The retained record provides continuity for user-related metadata. For example, after an employee leaves the organization, other users may still need to see that the former employee:
Created a document.
Modified an item.
Added a list entry.
Was previously assigned permissions.
Participated in historical SharePoint activity.
From this perspective, the orphaned record appears not harmless but useful. It helps SharePoint preserve the historical identity associated with existing content.
Should administrators treat every orphaned user as something that must immediately be deleted? I see Microsoft position is conflicting/controversial/ambiguous, as generally they say that legacy entry in the UIL is needed to preserve metadata but – at the same time – removal an orphan user from the UIL is OK, though primarily as a troubleshooting action for profile synchronization and mismatched-ID scenarios, rather than as routine indiscriminate cleanup (more: Is It Safe to Remove a User from a SharePoint UIL).
The Problem Appears When an Identity Is Recreated
Consider a common employee lifecycle scenario.
John Smith leaves the organization.
His Entra ID account is deleted.
SharePoint retains John’s entries in the UIL of sites where he previously appeared.
A year later, the organization hires another John Smith
The identity team creates a new Entra ID account using the same UPN, such as john.smith@contoso.com.
The new account looks similar to the old account: same display name, same email address, same UPN. However, it is not the same directory object. The recreated account receives a new internal identity value, even though its UPN matches the deleted account. Microsoft documents this as a primary cause of SharePoint and OneDrive user ID mismatch.
The same situation can also occur when the UPN is assigned to a rehired person.
From Entra ID’s perspective, the new account is a new security principal. From the affected SharePoint site’s perspective, however, the UPN may still be associated with the legacy UserInfo entry.
What Is a SharePoint User ID Mismatch?
A user ID mismatch occurs when the identity presented by the current user does not match the identity stored in SharePoint with the same UPN.
Conceptually, SharePoint sees something like this:
Attribute
Legacy account
New account
Display name
John Smith
John Smith
UPN
john.smith@contoso.com
john.smith@contoso.com
Entra ID object ID
Unique (Old value)
Unique (New value)
Although the UPN is the same, the internal identity is different.
Microsoft describes the underlying cause as follows: the recreated account receives a new ID, but the affected SharePoint or OneDrive UIL still contains the old ID. When the user attempts to access the site using the new account, the new identity does not match the identity stored in the site. Access can therefore be denied.
An Access denied message, while permissions appear correct
A message stating that a legacy account with the same email exists
Why Denying Existing Access Is Correct
At first glance, it may appear that SharePoint should automatically connect the new account to the old account because the UPN is identical. But that would create a security risk.
The same UPN does not mean that the new account represents the same person. Even if it is the same person, the individual may have returned in a different position, in another department, under different security requirements. So the new account should not automatically inherit the old account’s SharePoint permissions.
Therefore, SharePoint is correct not to treat the recreated account as the same security principal merely because the UPN matches. The more problematic behavior appears after an authorized site owner intentionally grants the new account access.
Where the Actual Operational Problem Begins
Suppose the new John Smith requests access to a site.
The site owner reviews the request and intentionally approves it. Alternatively, the site owner shares a site, library, folder, or document with the new account. From the site owner’s perspective, everything may appear correct:
The expected name and email are displayed
The user appears in the proper group (or with proper direct permissions)
The sharing (or approval) operation completes without an obvious error
However, the user may still be unable to access the resource because the site’s UIL contains the legacy identity associated with the same UPN.
SharePoint does not replace the old identity automatically when the new account is granted access. That is the practical limitation behind the user ID mismatch incidents.
Microsoft’s supported starting point is the Site User Mismatch diagnostic in the Microsoft 365 admin center. When a mismatch is found, the diagnostic can offer to remove the old identity from the affected site. After the old entry is removed, the new account must be assigned the appropriate permissions.
For a single user and site, this is usually manageable. At tenant scale, it becomes much more complicated.
Why Fixing One Site Is Not Enough
A recreated user rarely interacted with only one SharePoint site. During the person’s previous employment, the account may have been present in:
Many Team sites – as user can contribute to many projects, be involved in different activities
Publishing (Communication sites) – as user access corporate intranet and other org-wide sites
Shared OneDrive sites, as by default all documents shared in teams chats are shared via Onedrive
Viva Engage connected sites, as there is a SharePoint site behind every community
Removing the legacy identity from one affected site fixes only that site. The same user may encounter another issue tomorrow, next week, or several months later when attempting to access a different site.
This creates a recurring support pattern:
The user reports an access problem.
The administrator identifies and fixes a mismatch issue at the reported affected affected site.
The ticket is closed. User assumes his issue is fixed.
The user encounters the same problem on another site.
The investigation starts again. User is confused…
The technical fix is site-specific, while the identity lifecycle problem is potentially tenant-wide.
Why Discovering Every Affected Site Is Difficult
The obvious question is: Which SharePoint sites still contain the old identity?
SharePoint Online does not provide a simple out-of-the-box report listing every site collection whose UIL contains a specific legacy user. An administrator can technically scan SharePoint sites and inspect their users. However, this can be inefficient in a large tenant. For example, imagine a tenant with:
50,000 SharePoint sites.
A user who appeared in approximately 100 of those sites.
A straightforward tenant scan may need to inspect all 50,000 sites to locate the relevant 100.
The administrator knows the identity being investigated but does not know which site collections contain that identity. SharePoint’s user information is distributed across site collections rather than exposed through a convenient centralized orphan-user inventory.
It is possible to use PowerShell, but even for one affected user, a tenant-wide brute-force scan may consume considerable time and service resources relative to the number of useful results. The other option is to use 3-rd party tools.
Shifting Left: When Should the Problem Be Addressed?
Can we be proactive here? Probably yes… There are three general opportunities.
Option 1: After a Ticket Is Reported for one site, fix all affected sites
This is a “reactive-proactive” approach… We get tickets (reactively) but fix not one, but all affected sites for a user (proactively)
Workflow
A user reports that SharePoint access does not work.
The administrator runs the Site User Mismatch diagnostic and confirms that the account was created with the re-used UPN and user experiences User Id Mismatch issue.
The old user entry is removed from the reported site
The administrator makes all efforts to identify all affected sites for the user, and fix these sites
User is informed that the issue is fixed and that it must be a new share or approved access request
This approach is minimally proactive, it treats the symptom rather than the tenant-wide identity residue.
Option 2: Check Newly Created Accounts
The next shift-left opportunity occurs when an account is created. The idea is not to wait when user hits the issue. The organization could determine whether the UPN was previously used and then search for the corresponding legacy SharePoint identity, so the mismatch can be resolved before the user accesses SharePoint.
The challenge is the process must determine whether the UPN is genuinely new or reused. This approach can prevent tickets, but it requires reliable identity history.
Alternatively we can scan all new users to discover potential mismatched id, but this approach is much more expensive.
Option 3: Remove Legacy Site Entries During Offboarding
The earliest intervention point is employee offboarding.
Before deleting the Entra ID account, the organization still has a valid and identifiable user. It is easier to determine the SharePoint sites associated with a current identity than to reconstruct that information months or years later.
The offboarding process could be as follow:
Disable user account
Identify the SharePoint and OneDrive sites associated with the departing user
Delete user account
Remove the user from all sites UILs
Surely we know that most offboarded users will never return (deleted UPNs may never be reused) and removing every departing user from every site may be unnecessary, but it It addresses the problem at its earliest practical stage and ensures there is no future user ID mismatch incidents.
This is the most proactive approach, but it (as well as option 2) can also be an over-engineered solution if the actual mismatch rate is very low.
Again, as per Microsoft – an organization should not assume that universal deletion is automatically the best practice. Microsoft specifically describes UserInfo removal as a troubleshooting operation that should be performed for synchronization or mismatch scenarios when advised, rather than as a general cleanup requirement.
A Three-Workstream Strategy
For established tenants, a single activity not always completely solves the problem. A practical program can be a combination of three separate workstreams.
1. Clean Up Existing Orphaned Users
This workstream addresses the historical backlog already present in the tenant.
Imagine, we implemented remediation Option 3 (Remove Legacy Site Entries During Offboarding). For brand-new tenants that would guarantee no user id mismatch issues. But for mature tenants we already have a lot of legacy users, so we’ll definitely have issues related to mismatched is.
To ensure we do not have user id mismatch tickets – we wood need – stop bleeding (implement Option 3 Remove Legacy Site Entries During Offboarding) – clean-up existing orphaned users
Existing orphan users cleanup can require substantial effort in an old or large tenant because orphaned identities may have accumulated for many years, so we could have millions of orphaned users record (which means millions of deleting operations) – see more in “Estimate number of Orphaned Users and User Id Mismatch tickets.”
2. Stop Tickets
This workstream focuses on newly created or recreated accounts. Its purpose is to prevent a new employee or returning employee from encountering mismatch errors after receiving a Microsoft 365 account and before SharePoint access.
It does not remove the entire orphan-user backlog, so we’d still have a bunch of orphan users, but it can prevent visible incidents for newly created accounts. Having “Stop tickets” process implemented we guarantee user’s satisfaction, but that’s (imho) the most expensive process.
3. Stop the Bleeding
This workstream is triggered when users are offboarded. Its purpose is to prevent orphaned users, which would guarantee no new legacy identity conflicts. This is a future-state prevention activity.
Implementing “Stop Bleeding” process must be combined with clean-up efforts to achieve “Sop tickets”. Imho, this is the most logical way to remediate the issue. It might be complicated from the engineering efforts perspective, but would be the less resource-consuming approach after clean-up.
Tenant Age aChanges the Priority
The appropriate combination of these workstreams depends partly on the age of the tenant.
New Tenant
A newly created tenant has little or no legacy identity history.
The primary focus should therefore be:
Offboarding design
“Brute force” clean-up efforts
Established (or Old) Tenant
An old established tenant with many years of account turnover already contain many unresolved legacy (orphan) users entries. We are probably dealing with existing (ongoing) user ID mismatch cases.
The organization may need all three workstreams:
Clean up existing records
Improve future offboarding
Dealing with (or preventing) current tickets
Tenant Size Determines the Technical Approach
Small Tenants
In a small tenant, brute-force scanning may be acceptable. An administrator may be able to:
Enumerate all SharePoint sites.
Enumerate the users on each site.
Compare SharePoint identities with Entra ID identities.
Produce an orphan-user report.
Review and remediate the results.
A simple PowerShell script can be used (like this one from the “Orphan Users in Small Tenants” ). Depending on throttling, number of sites, the process might complete within a practical operational window.
Large Tenants
In a large tenant, a simple brute-force approach is impractical. This is not only “this should be done” but “this should be done in a most effective way” otherwise it might take forever. The solution may require:
Parallel processing with controlled concurrency
Throttling and retry handling
Delta-oriented identity processing
Site prioritization
Governance around retention and UPN reuse
At this scale, orphan-user management becomes an engineering and data-indexing problem rather than a simple administrative script. A 3-rd party tools might be required, in combination with custom PowerShell-based solutions.
Medium-Sized Tenants
To address an Orphaned Users and User Id Mismatch issue in a medium-sized tenant it may require a combination of approaches methods based on tenant size, age processes maturity, admins qualification and so on.
Employee Turnover Also Matters
Tenant size and age are not the only factors. Two organizations with the same number of users may experience very different levels of risk.
An organization with stable staffing and low turnover creates relatively few deleted identities. An organization that frequently hires contractors, seasonal workers, or temporary employees may create and delete a much larger number of accounts.
Is It Safe to Remove an Orphaned User?
This deserves its own detailed discussion.
Microsoft documents removal from the UIL as a way to troubleshoot mismatched identity and profile synchronization scenarios. At the same time, Microsoft warns that the removal procedure should be used for those troubleshooting purposes rather than as an unrestricted general cleanup method.
Another Way to Prevent User ID Mismatch: Identity Management
So far, we discussed the problem from a SharePoint administrator’s point of view. In that world, the typical solution is to find the legacy user in SharePoint and remove the old user entry from the User Information List.
However, there is another approach. Identity and Access Management (IAM) team can reduce or eliminate many User ID Mismatch issues by ensuring that each person receives a unique UPN that is never reused.
For example, instead of recreating:
john.smith@contoso.com
for a rehired employee, the organization could assign a different UPN, such as:
john_smith@contoso.com
or follow another naming standard that guarantees uniqueness.
With this approach, the new account never collides with the legacy SharePoint user record. As a result, User ID Mismatch issues do not occur.
Of course, this approach comes with its own challenges. Organizations often prefer to reuse the original UPN because it is easier for users, administrators, and business processes. In addition, changing naming standards may affect other systems that depend on predictable user names.
For that reason, UPN management should be viewed as an identity governance decision rather than a SharePoint administration task. SharePoint administrators can fix User ID Mismatch issues when they occur, but Identity and Access Management teams can often prevent those issues from appearing in the first place by implementing policies around account lifecycle management and UPN reuse.
In short, there are two ways to address User ID Mismatch:
SharePoint approach: Find and remove the legacy SharePoint user records that cause the conflict.
Identity management approach: Prevent UPN reuse so that the conflict never occurs.
The first approach is owned by SharePoint administrators. The second approach is owned by Identity and Access Management teams. In many organizations, the best long-term solution is a combination of both approaches.
Microsoft must address the issue
Anyway, the best possible resolution could be if Microsoft fix the product: at the moment when a new account is approved with access to the site (or site is shared by site owner with a user) – SharePoint can do clean-up internally – by replacing the old Id with the new Id.
“Orphan User” in SharePoint refers to a user account that no longer exists in Entra ID but is still present in the User Information List (UIL) on SharePoint sites.
Offboarded user accounts are usually deleted from the Entra ID directory sooner or later. However, SharePoint caches user information in its own databases. This information is stored in the so-called UIL (User Information List). Each site has its own User Information List.
Generally, orphan users are pretty harmless, as they are not users, but just ghost entities – records that reflects former accounts, i.e. these users cannot login, even when a new user is created with the same email – access is not possible. Moreover, legacy Microsoft documentation says such records are needed to preserve metadata – like who is the author of the document or documents editing history, etc.
So yes, orphan users are harmless until you hit a User ID Mismatch issue.
In a nutshell, a User ID Mismatch happens when an email address (UPN) is reused and a new user tries to access a SharePoint site where the old user previously had access.
SharePoint does not allow the new user to automatically inherit the same access that the old user had, and this is expected behavior. The issue is that SharePoint may fail to correctly grant access to the new user even after permissions have been assigned.
In such cases, you must first remove the old user ID from the site’s User Information List. This approach is recommended by Microsoft and considered as safe. And guess what? It turns out the old user is no longer needed in the UIL to preserve metadata 🙂
When a user hits a User ID Mismatch issue, it is often difficult to recognize that the problem is not simply missing permissions or a site owner not approving access, but an actual product limitation that prevents access to SharePoint. As a result, users become frustrated, support teams spend time troubleshooting the issue, and it may take a while before the root cause is identified and resolved.
So why not remediate the issue proactively? This way, there are no high-priority support tickets, no angry users, and no urgent troubleshooting when the problem eventually occurs.
The engineering problem behind all approaches to proactively resolving the User ID Mismatch issue is that there is no out-of-the-box (native) SharePoint report that provides a list of sites where a specific orphan user is present. You cannot simply press a button and get a complete list of orphan user/site pairs.
In general, you need to scan the entire tenant, site by site, including personal OneDrive sites, and retrieve all historical site users. Then you need to check whether each user stored in SharePoint still exists in Entra ID.
Multiply the number of sites by the number of users and see how long it might take. An average user typically has access to only ~1% of all sites in a tenant, so you can imagine how inefficient this approach can be.
However, for small tenants, we can still use this so-called brute-force approach. With this approach, we use PowerShell to do the job: identify all orphan users and, optionally, remove them.
Whether this is a viable solution depends on your specific situation: the size of your organization, employee turnover, the amount of data (number of sites), and the age of the tenant.
I may provide some kind of calculator in the future to estimate how long the process might take based on tenant characteristics. But the general idea is simple: in some cases, a brute-force approach is perfectly acceptable because it:
a) is very simple and does not require advanced PowerShell skills, and b) can be completed in a reasonable amount of time (minutes or hours)
A read-only PowerShell solution that evaluates governance, security, ownership, lifecycle, and operational controls across Microsoft 365 and highlights areas that require attention.
Microsoft enforces Content Security Policy (CSP) in SharePoint Online. What does that mean to SharePoint Admins? Should we be concerned? What do we need to undertake? Before? After?
Generally, in web development – the policy (Content Security Policy – CSP) is needed to minimize the risk of security threats by controlling which resources, in particular JavaScript resources, a page/site is allowed to load.
In SharePoint web development is done via SPFx, so the CSP policy affect SPFx solutions. In a nutshell, from now on, for the SPFx solutions to work properly, admins should whitelist external domains. Admins can maintain allowed domains list via GUI in SharePoint admin center or via PowerShell:
# List current sources
Get-SPOContentSecurityPolicy
# Remove a source
Remove-SPOContentSecurityPolicy -Source "https://cdn.host.com/source/"
# Add a source
Add-SPOContentSecurityPolicy -Source "https://cdn.host.com/source/"
The CSP policy was enforced on March 1, 2026, but as per Microsoft, if clients need more time to review and update existing SPFx solutions, we can delay the enforcement by 90 days, until June 1, 2026, via
Set-SPOTenant -DelayContentSecurityPolicyEnforcement $true
# IMPORTANT: List the applied setting again as mandatory step to correctly persist the setting (will be fixed)
(Get-SPOTenant).DelayContentSecurityPolicyEnforcement
And for the Set-SPOTenant cmdlet there are options related to CSP:
DelayContentSecurityPolicyEnforcement
EnforceContentSecurityPolicyConfiguration
ResyncContentSecurityPolicyConfigurationEntries
ContentSecurityPolicyEnforcement
So the question I ask for myself is what exactly each command does and how are the options correlated to each other and affect SPFx solutions.
Content Security Policy (CSP) in SharePoint: My Findings
ContentSecurityPolicyEnforcement
It seems like using Set-SPOTenant with a ContentSecurityPolicyEnforcement parameter change nothing. I.e. “Set-SPOTenant -ContentSecurityPolicyEnforcement:$false” does not disable policy and vise versa “Set-SPOTenant -ContentSecurityPolicyEnforcement:$true” does not enforce the CSP policy.
My guess it’s because this article is written in April 2026. Microsoft started Content Security Policy (CSP) enforcement since March 1, 2026. So probably before March 1, 2026 we could use ContentSecurityPolicyEnforcement to enable the policy, but since March 2026 the policy is enforced anyway and parameter ContentSecurityPolicyEnforcement is not needed (and probably will go away in the next versions of the Microsoft.Online.SharePoint.PowerShell Module).
DelayContentSecurityPolicyEnforcement
DelayContentSecurityPolicyEnforcement parameter effectively switches the policy on and off. It takes a few minutes for Microsoft to propagate the change across so you can start seeing the policy enforced or not. But this is true only during 90 days – in Mar, Apr and May 2026. Since June 1, 2026 the Content Security Policy (CSP) will be enforced in SharePoint Online.
Testing SPFx Solutions Before Enforcement
How do I know if my site compliant with CSP or not before CSP enforcement?
Use browser’s dev tools (F12). Select console and filter/search output with “policy”. You can find something like:
“Loading the image ‘<URL>’ violates the following Content Security Policy directive” or “Loading the script … violates the following Content Security Policy directive” or “Executing inline script violates the following Content Security Policy directive” or
If the message is just informational (in white) and there is also “The policy is report-only, so the violation has been logged but no further action has been taken.” that means the policy is not enforced yet… and the site functionality should not be affected.
Otherwise – when you see the same “… violates the following Content Security Policy directive” in red – this would be an error message and the policy prevents something on your site due to the CSP policy so functionality will be broken.
This article address “Orphaned Users” in SharePoint and applies mostly to medium and large tenants.
The problem statement
Orphaned users are user accounts that no longer exist in Entra ID (Azure AD) but still appear inside Microsoft 365 SharePoint or OneDrive sites, specifically in the User Information List (UIL). A SharePoint User Information List (UIL) is a hidden system list that exists in every SharePoint site collection and stores cached profile information about users who have interacted with that site. In short about orphaned users and UIL: The identity is gone, but its footprint remains.
Why Orphaned Users Must Be Removed?
Orphaned users should be eliminated not only because their presence in sites confuses active users, but mostly because they cause “User ID Mismatch” issues when UPNs are reused.
What is a “User ID Mismatch” issue in SharePoint?
User ID Mismatch is a known problem in SharePoint. It happens usually when a user account is deleted from the directory, and then a new account is created with the same UPN (re-used user principal name). Symptoms are: a user is provided with the access to the site, but still cannot get access.
The reason behind it is that SharePoint caches users data in the UIL, including not only UPN, but also Entra Id user object Id. So when a re-used UPN tries to access the site – SharePoint does not allow access, because even if UPN is the same – Id is different – e.g. SharePoint treats user as a different one. So access needs to be re-provided. And this is where the actual issue happens. When a site owner shares the resource with a new user (or approves access request) – Microsoft does dot update the UIL with the new user ids. So for the user and for the site owner it looks like access was provided, but in fact it was not.
How do we remove Orphaned Users
Microsoft provides a “fix”, but this solution is really weak as it allows only to remove one orphaned user from one site reactively. Here are some more details: “Fixing SharePoint User ID Mismatch Issue“.
Can we address the issue proactively, tenant-wide (all users, all sites, before the issue happens)? Probably – yes, but it takes a lot. Here are some more details: “Preventing SharePoint User ID Mismatch: a Tenant‑Wide Approach“. In a nutshell solution is at the moment of an employee offboarding – when a user account is deleted from directory (Entra Id) – we need to remove that user from all sites UIL they had access to. But how? And the other question: is it safe?
How do we remove deleted Entra is users from all SharePoint sites? This is a huge problem, as there is no native (out-of-the-box) Microsoft’s tools or reports to get all sites a specific user has access to. But here is where a 3-rd party tools might help. E.g. SysKit Point – with it’s “Orphaned Users” policy or ShareGate.
Is it safe to remove all orphaned users from all sites in SharePoint? Though Microsoft did not publicly say “yes” (at least I have not seen it), a high-skilled SharePoint support engineers says yes, generally it’s safe if you do it correctly. My research on the question says the same – yes, it is safe (“Is It Safe to Remove a User from a SharePoint UIL?“).
Can we just turn the SysKit’s “Orphaned Users” policy on? In small tenants – yes, in new tenants – yes. But your tenant is not new and not small – you probably already have tens or hundreds of thousands of orphaned users. Unfortunately, in SysKit there is no options to implement the policy in chunks – so we do orphaned users clean-up against test sites, then pilot, then step-by-step all other sites. Also the “orphaned users” report just fails due to enormous amount of data.
So the idea is to do an initial clean-up in the environment – gracefully remove all existing orphaned users before implementing “Orphaned Users” policy. This is exactly the topic of this KBA.
Initial Clean-Up of Orphaned Users in large Microsoft 365 tenants
A controlled, script-based clean-up must be completed before the Orphaned Users policy can be safely enabled. PowerShell is identified as the primary tool for this effort.
Below is a draft (preliminary considerations) – to be tested/proved/updated.
Scale of the Problem (sample large Microsoft 365 tenant):
Approximately 500,000 sites (~200k SharePoint + 300k OneDrive sites)
Approximately 500,000 orphaned users
Approximately 300,000 normal users
Key Constraints and Challenges
No existing report that maps orphaned users to sites
Full enumeration of sites and users is expensive and time-consuming
Microsoft throttling limits must be respected
Some sites have extremely large User Information Lists (UILs)
Orphan detection must not rely on UPNs due to reuse
Processing must be resumable and trackable
High-Level Strategy
The clean-up approach must:
Support piloting and phased execution
Reduce orphaned user count enough for SysKit reporting to function (no need in total “zero orphan” cleanup)
Minimize tenant-wide risk
Recommended initial strategy:
Exclude new sites and external sites
Identify large sites and process them separately
Begin with medium-sized sites
Validate approach using small but active sites before scaling
Execution Model
For each site processed:
Retrieve users from the site’s User Information List (UIL)
Check each user to determine orphan status
Remove orphaned users immediately
Avoid report-only runs except for limited analysis
Deleting orphans immediately avoids duplicate scanning and unnecessary re-validation.
Orphan Detection Approach
Preferred identifier: Entra ID Object ID. UPNs must not be used to determine orphan status due to reuse.
Options considered:
Query Entra ID for every user
Accurate but expensive
Repeats checks for the same users
Maintain a cached list of existing users
Risk of missing newly added users
Large list reduces efficiency
Recommended technique:
Maintain a list of orphaned users by Entra Object ID
If Object ID is known orphaned, it is orphaned everywhere permanently
Check UIL user Object ID against this list first
If unavailable, fall back to Entra ID lookup
Note: UIL does not always store Entra Object ID directly; sometimes only login name (claim) is available.
Handling Large Sites
Get-PnPUser does not support paging
Direct access to the User Information List (UIL) with paging is required
Large UILs can cause failures if not paged properly
Workers and Parallel Processing
The clean-up cannot be completed with a single script run.
Expected characteristics:
Hundreds or thousands of executions
Parallel workers required
Throttling must be handled gracefully
Processing must be resumable
Worker execution options:
Manual runs from a VM (e.g., nightly)
Scheduled Azure jobs (Function App or Automation Account)
With multiple workers, a global STOP flag should be supported.
Tracking and State Management
Tracking is mandatory to avoid reprocessing completed work.
Tracking by user-site pairs is not feasible due to scale.
Preferred approach: Tracking by site.
Minimum tracking fields per site:
SiteUrl
State (Pending | InProgress | Done | Failed)
LastProcessedDateTime
AttemptCount
LastError
Metrics:
UsersScanned
OrphansFound
OrphansRemoved
DurationSeconds
Tracking Storage Options
SharePoint list: not suitable at scale
CSV: Pros: simple Cons: slow, co-authoring issues
SQL: Pros: fast, reliable Cons: complex
Azure Table Storage or Cosmos Table API: viable option
Each worker:
Takes a site
Marks the site InProgress (with a lease)
Scans UIL in pages
Removes orphaned users
Logs actions and metrics
Marks site Done
Reused UPNs and User ID Mismatch
Because the tenant contains many reused UPNs:
UPN must not be used to determine orphan status
Entra ID Object ID must be used wherever possible
Deleting users by site user ID or login name is safe because reused UPNs are not added to UIL until the previous orphan entry is removed.
An alternative approach is to skip reused UPNs entirely:
This is safe from a risk perspective
But it misses an opportunity to fix User ID Mismatch issues
This tradeoff may be acceptable if performance gains are significant.
