Hierarchy Security Configuration

Complete the full lesson to earn 25 points

Work through each section, then tap “Mark as Complete” on the last one.

Section 1 of 12

✦ Skip the page breaks and see fewer ads — read each lesson on a single page with Pro

Hierarchy Security Configuration in Microsoft Dataverse

Welcome to this in-depth lesson on Hierarchy Security Configuration within Microsoft Dataverse. In the world of business applications, ensuring that the right people have access to the right information is paramount. Dataverse provides a robust security model that allows organizations to protect their data, and hierarchy security is a powerful, yet often misunderstood, component of this model.

At its core, hierarchy security extends Dataverse's existing security model by granting users access to records owned by their subordinates, based on their organizational structure. Imagine a sales manager who needs to see all the sales opportunities, accounts, and activities of their direct reports. Or a project lead who needs visibility into tasks and cases handled by their team members, even if those team members belong to different departments. Hierarchy security is designed precisely for these scenarios, making it easier to manage data access in organizations with layered reporting structures without creating countless sharing rules or complex security role assignments.

This lesson will demystify hierarchy security, exploring its two main types: Manager Hierarchy and Position Hierarchy. We'll dive into how each works, when to use them, and walk through the configuration steps. We'll also cover best practices, discuss potential pitfalls, and provide practical examples to help you effectively implement and manage this crucial aspect of Dataverse security. Understanding and correctly configuring hierarchy security is vital for maintaining data integrity, ensuring compliance, and empowering your teams with the necessary data visibility to perform their jobs effectively.

Core Concepts of Hierarchy Security

Hierarchy security in Dataverse primarily focuses on providing read, write, update, delete, append, and append to access to records owned by subordinates. This access is granted in addition to any access provided by security roles and business units. If a user already has access to a record through their security role, hierarchy security won't grant more access, but it can grant access to records they otherwise wouldn't see.

There are two distinct types of hierarchy security available in Dataverse:

1. Manager Hierarchy

Manager hierarchy is the simpler and more common type. It's based directly on the "Manager" field within the user record. Every user can have a single manager, forming a straightforward chain of command.

How it works: When manager hierarchy is enabled, a manager gains access to records owned by their direct reports. This access can then extend further down the hierarchy for a specified number of levels, known as the "Depth." For example, a Vice President might gain access to records owned by their Sales Directors, and through those Sales Directors, also gain access to records owned by the Sales Representatives who report to the Sales Directors.
Prerequisites: For manager hierarchy to function, the Manager (parentsystemuserid) lookup field on each user record must be correctly populated, linking users to their respective managers.
Use Cases: Ideal for organizations with a clear, direct reporting structure where access needs to follow the chain of command. This is typical in many sales, service, or administrative departments.

2. Position Hierarchy

Position hierarchy offers greater flexibility and is designed for more complex organizational structures, such as matrix organizations, project-based teams, or situations where a user might need access based on their role within a specific function rather than just their direct manager.

How it works: Instead of relying on the direct manager field, position hierarchy uses a custom "Position" entity. You define positions (e.g., "Sales Director - North America," "Project Lead - Alpha Project") and then assign users to one or more positions. Crucially, positions themselves are arranged in a hierarchical structure, where one position can be a parent to another. A user in a higher position then gains access to records owned by users assigned to subordinate positions, again up to a specified depth.
Prerequisites: This requires defining custom Position records and then associating users with these positions, typically via a lookup field on the user record. You also need to establish the parent-child relationships between the Position records themselves.
Use Cases: Perfect for organizations where reporting lines are fluid, where individuals might report to different managers for different projects, or where access needs to be granted based on functional roles rather than strict managerial reporting.

Callout: Why Two Types?

The existence of both Manager and Position Hierarchy addresses different organizational needs. Manager Hierarchy is quick to set up and maintain for traditional, top-down reporting structures. It's ideal when a direct line of command dictates data visibility. Position Hierarchy, on the other hand, provides a more adaptable and robust solution for complex, dynamic, or matrix organizations. It decouples access from the direct managerial relationship, allowing for access based on functional roles or project leadership, which might span across different direct reporting lines. Choosing the right type depends entirely on your organization's specific structure and data access requirements.

Manager Hierarchy Configuration

Configuring Manager Hierarchy is generally straightforward, provided your user records accurately reflect your organizational reporting structure.

Prerequisites: Setting the Manager Field

The most critical prerequisite for Manager Hierarchy is ensuring that every user who is a subordinate has their "Manager" field populated with the correct manager's user record.

You can set this in a few ways:

Manually in Dataverse:
1. Navigate to the Power Platform Admin Center (admin.powerplatform.microsoft.com).
2. Select your environment.
3. Go to Settings > Users + permissions > Users.
4. Select a user, then click Edit.
5. Locate the Manager field and select the appropriate manager from the lookup.
6. Save the changes.
Bulk Update: For many users, you might perform a bulk edit via Excel import/export or use the Dataverse Web API/SDK to update the parentsystemuserid field for multiple systemuser records.
Azure AD Sync: If your Dataverse users are synchronized from Azure Active Directory, ensure that the manager attribute in Azure AD is correctly populated, as this will typically sync to Dataverse.

Enabling and Configuring Manager Hierarchy

Once your manager relationships are established, you can enable and configure the hierarchy security:

Access Power Platform Admin Center: Go to admin.powerplatform.microsoft.com.
Select Environment: Choose the specific Dataverse environment where you want to configure hierarchy security.
Navigate to Security Settings: In the environment settings, go to Settings > Users + permissions > Hierarchy security.
Choose Hierarchy Model: Select Manager Hierarchy from the dropdown list.
Configure Depth:
- Hierarchy Depth: This setting determines how many levels down the hierarchy a manager will gain access to records. A depth of 1 means a manager sees records of their direct reports. A depth of 2 means they see records of their direct reports and the direct reports of those reports, and so on.
- Tip: Start with a conservative depth, like 1 or 2, and only increase if necessary. Deeper hierarchies can have a greater impact on performance.
Select Entities:
- Enabled Entities: By default, no entities are enabled for hierarchy security. You must explicitly select the entities for which you want hierarchy security to apply. For example, you might enable it for Account, Contact, Opportunity, Lead, and Case.
- Warning: Only enable hierarchy security for entities where it's truly required. Enabling it for all entities can unnecessarily increase the system overhead and potentially grant broader access than intended.
Choose Access Privileges:
- For each selected entity, you can specify the types of access that will be granted to managers over their subordinates' records. Options typically include:
  - Read: View records.
  - Write: Modify records.
  - Update: Modify records (often combined with Write).
  - Delete: Remove records.
  - Append: Attach records (e.g., attach a note to an opportunity).
  - Append To: Be attached to records (e.g., be associated with an activity).
- It's common to start with Read access and only grant Write or other privileges if the business process truly requires managers to directly modify their subordinates' records.
Activate: After configuring the settings, click Save or Activate to apply the changes. The system will then begin calculating and applying the hierarchy security rules.

Example Scenario: Sales Manager Access

Let's consider a sales team structure:

Sarah (VP Sales)
- John (Sales Director - East)
  - Maria (Sales Rep - NY)
  - David (Sales Rep - MA)
- Emily (Sales Director - West)
  - Mark (Sales Rep - CA)

If we configure Manager Hierarchy with a depth of 2 and grant Read access to Opportunity records:

John will automatically get Read access to Opportunity records owned by Maria and David.
Emily will automatically get Read access to Opportunity records owned by Mark.
Sarah will automatically get Read access to Opportunity records owned by John, Emily, Maria, David, and Mark (because John and Emily are her direct reports, and Maria, David, and Mark are their reports, thus falling within a depth of 2).

This significantly reduces the administrative burden compared to manually sharing each opportunity record or creating complex security roles that might over-privilege users.

Position Hierarchy Configuration

Position Hierarchy offers a more flexible approach, suitable for organizations with complex or evolving structures that don't neatly fit a direct managerial chain.

When to Use Position Hierarchy

Matrix Organizations: Where individuals report to different managers for different projects or functions.
Project-Based Teams: Where a project lead needs access to all project-related records, regardless of the team members' departmental reporting lines.
Functional Access: When access needs to be based on a specific role or function rather than just a direct manager.
Frequent Organizational Changes: Position hierarchy can be more resilient to personnel changes, as users can be moved between positions without redesigning the entire reporting structure.

Creating and Structuring Positions

Unlike Manager Hierarchy, Position Hierarchy requires defining "Position" records and establishing their hierarchy before associating users.

Define Positions:
- Positions are custom records in Dataverse, typically managed through a dedicated entity (e.g., Position).
- Each position record needs a name (e.g., "North America Sales Lead," "Project Alpha Manager").
- Crucially, each position record also needs a lookup to a "Parent Position" field to establish the hierarchy.
- You can create these records manually or import them.
- Example:
  - Position: "Global Sales Head" (Parent: None)
  - Position: "EMEA Sales Director" (Parent: "Global Sales Head")
  - Position: "APAC Sales Director" (Parent: "Global Sales Head")
  - Position: "UK Sales Lead" (Parent: "EMEA Sales Director")
Assign Users to Positions:
- Once positions are defined and their hierarchy is set, you need to link users to these positions.
- This is done by adding a lookup field on the User entity (e.g., new_positionid) that points to your Position entity.
- Each user is then assigned to one or more positions. For simplicity, most implementations assign users to a single primary position for hierarchy purposes.
- Example:
  - User: "Alice" assigned to Position: "Global Sales Head"
  - User: "Bob" assigned to Position: "EMEA Sales Director"
  - User: "Charlie" assigned to Position: "UK Sales Lead"

Enabling and Configuring Position Hierarchy

The steps for enabling Position Hierarchy are similar to Manager Hierarchy, but with the critical difference of selecting the Position Hierarchy model.

Access Power Platform Admin Center: Go to admin.powerplatform.microsoft.com.
Select Environment: Choose your Dataverse environment.
Navigate to Security Settings: Go to Settings > Users + permissions > Hierarchy security.
Choose Hierarchy Model: Select Position Hierarchy from the dropdown list.
Configure Depth:
- Hierarchy Depth: Similar to Manager Hierarchy, this defines how many levels down the position hierarchy a user will gain access to records owned by users in subordinate positions.
Select Entities:
- Enabled Entities: Choose the specific entities for which position hierarchy security should apply (e.g., Project, Task, Case).
Choose Access Privileges:
- Specify the types of access (Read, Write, Delete, etc.) that will be granted to users in higher positions over records owned by users in subordinate positions for the selected entities.
Activate: Click Save or Activate to apply the changes.

Example Scenario: Project Team Access

Consider a project team structure defined by positions:

Position: "Project Manager - Alpha" (Parent: None)
- Position: "Lead Developer - Alpha" (Parent: "Project Manager - Alpha")
  - Position: "Junior Developer - Alpha" (Parent: "Lead Developer - Alpha")
- Position: "QA Lead - Alpha" (Parent: "Project Manager - Alpha")
  - Position: "QA Tester - Alpha" (Parent: "QA Lead - Alpha")

Now, assign users to these positions:

User: Peter is in "Project Manager - Alpha"
User: Laura is in "Lead Developer - Alpha"
User: Tom is in "Junior Developer - Alpha"
User: Sarah is in "QA Lead - Alpha"
User: Mike is in "QA Tester - Alpha"

If we configure Position Hierarchy with a depth of 2 and grant Read access to Project Task records:

Laura (Lead Developer) gets Read access to Project Task records owned by Tom (Junior Developer).
Sarah (QA Lead) gets Read access to Project Task records owned by Mike (QA Tester).
Peter (Project Manager) gets Read access to Project Task records owned by Laura, Tom, Sarah, and Mike (because Laura and Sarah are in direct subordinate positions, and Tom and Mike are in positions subordinate to them, falling within a depth of 2).

This allows the Project Manager to oversee all tasks within the project, even if the developers and QA testers report to different functional managers outside of this project structure.

Comparison: Manager vs. Position Hierarchy

Choosing between Manager and Position Hierarchy is a key design decision. Here's a quick comparison:

Feature/Aspect	Manager Hierarchy	Position Hierarchy
Basis	`Manager (parentsystemuserid)` field on User record	Custom `Position` entity with parent-child relationships
Setup Complexity	Lower, relies on existing user data	Higher, requires defining positions and assigning users
Flexibility	Lower, tied to direct reporting structure	Higher, allows for complex, non-direct reporting structures
Maintenance	Updates when user's manager changes	Updates when user's assigned position changes, or position hierarchy changes
Scalability	Good for linear structures	Better for complex, matrix, or project-based structures
Ideal Use Case	Traditional organizational charts, direct reporting	Matrix organizations, project teams, functional roles

Callout: The Power of Hierarchy Depth

The 'Hierarchy Depth' setting is a critical control point. It defines the reach of the hierarchy security. A depth of 1 means a manager only sees records of their direct reports (or a user in a parent position sees records of users in directly subordinate positions). A depth of 2 means they see records of their direct reports and their direct reports' direct reports, and so on. Setting this too high can grant unintended broad access and negatively impact performance. Always opt for the minimum necessary depth to meet business requirements.

Configuration Steps (General Overview)

Here's a generalized step-by-step guide applicable to both Manager and Position Hierarchy, emphasizing the common process in the Power Platform Admin Center:

Prepare Your Data:
- For Manager Hierarchy: Ensure all systemuser records have the Manager (parentsystemuserid) lookup field correctly populated.
- For Position Hierarchy:
  - Create your custom Position entity and populate it with all necessary positions.
  - Establish the parent-child relationships between your Position records.
  - Create a lookup field on the systemuser entity (e.g., new_positionid) that points to your Position entity.
  - Assign each systemuser to their relevant Position record using this new lookup field.
Navigate to Power Platform Admin Center: Open your web browser and go to admin.powerplatform.microsoft.com.
Select Your Environment: From the environments list, click on the name of the Dataverse environment where you intend to configure hierarchy security.
Access Environment Settings: On the environment details page, click on Settings in the top navigation bar.
Locate Hierarchy Security: In the settings panel, expand Users + permissions and then click on Hierarchy security.
Choose Hierarchy Model:
- In the "Hierarchy Model" dropdown, select either Manager Hierarchy or Position Hierarchy based on your organizational needs and data preparation.
Set Hierarchy Depth:
- Enter a numerical value in the "Hierarchy Depth" field. This determines how many levels down the hierarchy access will extend.
Select Entities for Security:
- In the "Enabled Entities" section, click Add entity.
- A panel will appear. Search for and select the specific Dataverse entities (e.g., Account, Opportunity, Case, Project Task) for which you want hierarchy security to apply.
- For each selected entity, use the checkboxes to specify the Access Privileges (Read, Write, Delete, Append, Append To) that managers/higher positions will gain over their subordinates' records.
- Click Add to confirm your entity selections. Repeat for all necessary entities.
Save and Activate:
- After making all your selections and settings, click the Save button at the bottom of the page.
- The system will then process the configuration and apply the hierarchy security rules. This might take a moment depending on the size and complexity of your data and hierarchy.

Note: Hierarchy security is an organizational-level setting. Once configured, it applies across the entire Dataverse environment for the selected entities and users. There is no way to apply it only to a subset of business units or users, beyond what is naturally filtered by the hierarchy structure itself.

Impact and Performance Considerations

While incredibly useful, hierarchy security does come with performance implications that need to be understood and managed.

Data Access Calculation: When a user attempts to access a record, Dataverse's security engine must evaluate all applicable security rules, including hierarchy security. This involves traversing the hierarchy to determine if the user has access through their position relative to the record owner.
Deep Hierarchies: The deeper the hierarchy (i.e., a higher "Hierarchy Depth" value), the more complex these calculations become. A user at the top of a deep hierarchy might potentially need to evaluate access to records across many levels of subordinates, which can be resource-intensive.
Large Number of Records: If you enable hierarchy security for entities with a very large number of records, and these records are distributed across a deep hierarchy, the performance impact can be more noticeable.
Frequent Changes: If your organizational hierarchy changes frequently (users moving managers, positions being redefined), the system needs to re-evaluate and apply these changes, which can consume resources.

Best Practices for Optimizing Performance:

Minimize Hierarchy Depth: As mentioned, start with the lowest possible depth (e.g., 1 or 2) and only increase if a clear business need dictates it.
Limit Enabled Entities: Only enable hierarchy security for entities that absolutely require it. Do not enable it for every entity by default.
Leverage Other Security Models: Hierarchy security complements, but does not replace, security roles and business units. Use these fundamental layers to provide broad access, and then use hierarchy security for the specific "managerial oversight" access where needed. Don't try to use hierarchy security to solve all access problems.
Monitor Performance: Regularly monitor your Dataverse environment's performance, especially after implementing or significantly changing hierarchy security. Look for slow form loads, query execution times, or report generation.
Scheduled Maintenance: If using Position Hierarchy, consider if position updates can be batched or scheduled during off-peak hours if they are frequent and extensive.

Best Practices and Recommendations

Implementing hierarchy security effectively requires careful planning and adherence to best practices.

Design Your Hierarchy Carefully:
- Simplicity is Key: Aim for the simplest hierarchy that meets your business needs. Overly complex structures can be difficult to manage and debug.
- Accurate Data: Ensure your Manager fields for Manager Hierarchy or Position assignments and Parent Position relationships for Position Hierarchy are accurate and up-to-date. Inaccurate data will lead to incorrect access.
Start Small, Iterate, and Test:
- Begin with a minimal hierarchy depth and for a limited set of critical entities.
- Thoroughly test the access for various users at different levels of the hierarchy in a non-production environment before deploying to production. Verify both that users have the expected access and that they do not have unintended access.
Use the Right Type of Hierarchy:
- If your organization has a clear, relatively static reporting structure, Manager Hierarchy is often the best choice due to its simplicity.
- For dynamic, matrix, or project-based organizations, invest the time to set up Position Hierarchy for greater flexibility.
Define Access Privileges Thoughtfully:
- Principle of Least Privilege: Grant only the necessary access privileges (Read, Write, Delete, etc.). Do not grant Write access if Read access is sufficient.
- Most organizations primarily use hierarchy security for "Read" access (oversight), with "Write" access being granted only for specific, approved scenarios.
Document Your Configuration:
- Maintain clear documentation of your hierarchy structure, the chosen hierarchy type, depth, and the entities/privileges enabled. This is invaluable for troubleshooting and future modifications.
Regular Review and Audit:
- Periodically review your hierarchy structure and security settings. Organizational structures change, and your hierarchy security configuration should evolve with them.
- Utilize Dataverse auditing features to track who accessed which records, which can help in verifying that hierarchy security is working as intended.
Complement, Don't Replace, Other Security:
- Hierarchy security works in addition to security roles and business units. It's not a standalone solution. Leverage security roles for entity-level and basic record-level access, business units for data segregation, and then hierarchy security for specific vertical access needs.

Common Pitfalls and How to Avoid Them

Even with careful planning, there are common mistakes that can arise when configuring hierarchy security.

Incorrect or Incomplete Hierarchy Data:
- Pitfall: Users' Manager fields are empty or point to the wrong manager, or Position records are not properly linked or users are not assigned to positions.
- Avoidance: Implement robust processes for user onboarding and updates that include populating manager/position fields. Use bulk updates or integrations to ensure data accuracy. Regularly audit these fields.
Overly Broad Access (Too Much Depth or Too Many Entities):
- Pitfall: Setting a very high hierarchy depth (e.g., 10 levels) or enabling hierarchy security for too many entities, leading to unintended data exposure or performance issues.
- Avoidance: Start with minimal depth and only for critical entities. Incrementally increase depth or add entities only when a clear business requirement dictates it, and always test thoroughly. Adhere to the principle of least privilege.
Performance Degradation:
- Pitfall: Slow form loads, reports, or queries due to the overhead of evaluating deep hierarchies or many records.
- Avoidance: Follow performance best practices: minimize depth, limit enabled entities, and monitor performance metrics. If issues arise, reconsider your hierarchy design or offload some access requirements to security roles.
Conflicting Security Rules:
- Pitfall: Misunderstanding how hierarchy security interacts with existing security roles, leading to confusion about why a user can or cannot see a record.
- Avoidance: Remember that Dataverse security is additive. If a user has access through any security mechanism (security role, sharing, hierarchy security), they will see the record. If a user doesn't have access through a security role, hierarchy security can grant it. Design your security roles to provide baseline access, and then use hierarchy security for the specific hierarchical oversight.
Lack of Documentation:
- Pitfall: No clear record of why certain depths were chosen, which entities are enabled, or how the hierarchy is structured.
- Avoidance: Document everything! This is crucial for future administrators, troubleshooting, and compliance audits. Include diagrams of your hierarchy, especially for Position Hierarchy.
Ignoring User Feedback:
- Pitfall: Users reporting they can't see records they expect to, or seeing records they shouldn't, but their feedback is dismissed without investigation.
- Avoidance: Take user feedback seriously. It's often the first indicator of a misconfigured security setting. Use the "Access Checker" feature in Dataverse (if available in your environment) or impersonate users to debug access issues.

Practical Example: Programmatic User Manager Update

While much of hierarchy configuration is done in the Power Platform Admin Center, the underlying data (like a user's manager) can be managed programmatically. This is particularly useful for bulk updates or integrations with HR systems.

Here's a conceptual C# code snippet demonstrating how to update a user's manager using the Dataverse SDK. This illustrates how the parentsystemuserid field is critical for Manager Hierarchy.

using Microsoft.Xrm.Sdk;
using Microsoft.Xrm.Sdk.Query;
using System;

// This is a conceptual example.
// In a real application, you would need to set up proper authentication
// and establish an IOrganizationService connection.
// For simplicity, error handling and full connection setup are omitted.

public class HierarchySecurityExample
{
    // Assume 'service' is an initialized IOrganizationService instance
    private IOrganizationService _service;

    public HierarchySecurityExample(IOrganizationService service)
    {
        _service = service;
    }

    /// <summary>
    /// Updates the manager for a specific user.
    /// This directly impacts Manager Hierarchy security.
    /// </summary>
    /// <param name="subordinateUserId">The GUID of the user whose manager is being set.</param>
    /// <param name="managerUserId">The GUID of the user who will be the manager.</param>
    public void SetUserManager(Guid subordinateUserId, Guid managerUserId)
    {
        try
        {
            // Create an Entity object for the systemuser to update
            Entity userToUpdate = new Entity("systemuser", subordinateUserId);

            // Set the 'parentsystemuserid' field to an EntityReference of the manager
            // This is the lookup field that defines the manager in Dataverse.
            userToUpdate["parentsystemuserid"] = new EntityReference("systemuser", managerUserId);

            // Perform the update operation
            _service.Update(userToUpdate);

            Console.WriteLine($"Successfully updated manager for user ID: {subordinateUserId} to manager ID: {managerUserId}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error updating user manager: {ex.Message}");
            // In a real application, you would log the exception and handle it appropriately.
        }
    }

    /// <summary>
    /// Assigns a user to a specific position for Position Hierarchy.
    /// Assumes a custom lookup field 'new_positionid' on the systemuser entity.
    /// </summary>
    /// <param name="userId">The GUID of the user to assign.</param>
    /// <param name="positionId">The GUID of the custom Position record.</param>
    public void AssignUserToPosition(Guid userId, Guid positionId)
    {
        try
        {
            // Create an Entity object for the systemuser to update
            Entity userToUpdate = new Entity("systemuser", userId);

            // Set the custom lookup field (e.g., 'new_positionid') to an EntityReference of the position
            // The schema name of your custom Position entity might be 'new_position'
            userToUpdate["new_positionid"] = new EntityReference("new_position", positionId); 

            // Perform the update operation
            _service.Update(userToUpdate);

            Console.WriteLine($"Successfully assigned user ID: {userId} to position ID: {positionId}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error assigning user to position: {ex.Message}");
            // In a real application, you would log the exception and handle it appropriately.
        }
    }

    // Example usage (within a main method or similar)
    /*
    public static void Main(string[] args)
    {
        // Placeholder for your IOrganizationService setup
        IOrganizationService dataverseService = GetOrganizationService(); // Your method to get the service

        HierarchySecurityExample example = new HierarchySecurityExample(dataverseService);

        // Example for Manager Hierarchy
        Guid subordinate1 = new Guid("YOUR_SUBORDINATE_USER_GUID_1");
        Guid manager1 = new Guid("YOUR_MANAGER_USER_GUID_1");
        example.SetUserManager(subordinate1, manager1);

        // Example for Position Hierarchy
        Guid userForPosition = new Guid("YOUR_USER_GUID_FOR_POSITION");
        Guid specificPosition = new Guid("YOUR_POSITION_RECORD_GUID");
        example.AssignUserToPosition(userForPosition, specificPosition);
    }

    private static IOrganizationService GetOrganizationService()
    {
        // Implement your Dataverse connection logic here
        // This typically involves using CrmServiceClient or ServiceClient from Microsoft.Xrm.Tooling.Connector
        // or directly using the OrganizationWebProxyClient/CrmServiceContext with authentication.
        throw new NotImplementedException("Dataverse service connection not implemented.");
    }
    */
}

Explanation of the Code Snippet:

SetUserManager Method:
- This method targets the systemuser entity, which represents users in Dataverse.
- It creates an Entity object initialized with the subordinateUserId.
- The crucial part is setting the parentsystemuserid attribute. This is a lookup field on the systemuser entity that points to another systemuser record, effectively defining the manager. We create an EntityReference to the managerUserId to populate this lookup.
- The _service.Update(userToUpdate) call then persists this change to Dataverse. Once updated, if Manager Hierarchy is enabled, the manager will gain access to records owned by this subordinate.
AssignUserToPosition Method:
- This method also targets the systemuser entity.
- It assumes you have created a custom lookup field on the systemuser entity, for example, new_positionid, which links a user to a record in your custom new_position entity.
- It creates an EntityReference to the positionId (the GUID of your custom Position record) and sets this custom lookup field.
- Updating this field links the user to a position, which is fundamental for Position Hierarchy to work.

These programmatic approaches are vital for maintaining large user bases or integrating Dataverse with other HR or identity management systems to keep the hierarchy data synchronized.

Key Takeaways

Hierarchy security is a powerful tool in the Dataverse security arsenal, designed to simplify access management for organizations with structured reporting lines. Here are the key takeaways:

Extends, Not Replaces, Core Security: Hierarchy security works in conjunction with security roles and business units. It grants additional access based on organizational structure, complementing the foundational security layers.
Two Models for Different Needs:
- Manager Hierarchy: Ideal for direct, linear reporting structures, relying on the Manager field on user records.
- Position Hierarchy: Offers greater flexibility for complex, matrix, or project-based organizations, utilizing a custom Position entity and its hierarchical relationships.
Controlled Depth and Specific Entities: Configuration involves setting a "Hierarchy Depth" (how many levels down access extends) and explicitly selecting the entities for which hierarchy security applies. Always use the minimum necessary depth and enable only essential entities to optimize performance and prevent over-privileging.
Careful Planning and Accurate Data are Crucial: The effectiveness of hierarchy security hinges on accurate and up-to-date user data (manager assignments or position assignments). Poor data leads to incorrect access. Plan your hierarchy structure thoroughly before implementation.
Performance Considerations are Important: Deep hierarchies and enabling security for many entities can impact system performance. Monitor your environment and adhere to best practices like limiting depth and entities to mitigate these risks.
Principle of Least Privilege: When defining access privileges (Read, Write, Delete, etc.), grant only the permissions absolutely required by the business process. Read access is typically sufficient for managerial oversight.
Test, Document, and Review: Always test your hierarchy security in a non-production environment, document your configuration choices, and regularly review your hierarchy structure and access rules to adapt to organizational changes and ensure continued compliance and security.