PIM for Groups: Azure and Entra Access Design Guide

Back in March, in Entra vs Azure RBAC, I said I’d follow up with how to implement Privileged Identity Management across Entra and Azure. A reader even said she was looking forward to it in the comments. It’s taken me a while, but here it is, and for me the answer is PIM for Groups.

The mechanics of PIM aren’t the hard part. Making someone eligible for a role takes a few clicks. The hard part is designing something people will actually use once there are dozens of roles across management groups, subscriptions and Entra.

Here’s where it usually goes wrong. An engineer needs to do a normal day’s work, so they activate one role, then another, then a third. Each activation asks for a justification. By the end of the week, they’re asking for standing access back, and honestly I can’t blame them. Microsoft call out the same problem in their PIM deployment guidance: someone with five or six eligible roles has to activate each one individually.

The fix is PIM for Groups, but only if you design the groups properly. In this post I’ll walk through the model I use, how it works in Azure, why Entra needs handling differently, and where Microsoft’s limits will shape your design.

The Model: Role Groups and Permission Groups

The model splits access into two questions: who is this person, and what can that job do? Each question gets its own type of group.

Role group Permission group
Answers Who you are: your team and level What the access does
Example name PIM-Platform-L2 AZ-Connectivity-Contributor
Members People, as eligible members Role groups, as active members
Holds No roles of its own The Azure role assignment

The people only ever touch the role group. They activate it once and get everything that level of their team needs.

The permission groups stay stable. If PIM-Platform-L2 needs access to something new, you add that role group to another permission group. You aren’t making a list of engineers eligible for yet another role, and nobody has to remember a new activation.

This also makes the answer to “who can do what?” much easier to read. A person’s access is their role group, and a role group’s access is its list of permission groups.

I make eligibility time-bound. When someone moves teams, remove eligibility as part of the move. Expiry gives you a renewal decision if the assignment is still in place.

How PIM for Groups Works in Azure

Azure is where this model works best, because Azure role assignments are transitive for groups. If a user is a member of a group, and that group is a member of a group holding a role assignment, the user gets the permissions.

In this design, the role group is managed in PIM and sits inside ordinary Azure permission groups. The permission groups sit outside PIM. Microsoft’s best practice is not to use nested groups with PIM for Groups. Their concern is a non-role-assignable group sitting inside a role-assignable one, because admins of the lower group get a path to privileged roles. That’s why the Azure and Entra designs differ here. The transitive behaviour is specific to Azure RBAC, so check how a service handles group membership before using the same pattern elsewhere.

That gives us a simple chain:

  1. The engineer is an eligible member of their role group.
  2. The role group is an active member of one or more permission groups.
  3. Each permission group has an active Azure role assignment at the right scope.
  4. The engineer activates the role group once, and every role behind it applies.

Here’s an illustration of how the levels might map out for a platform team.

Level Typical work Example permission groups Example scope
L1 Investigate and support Reader, Monitoring Reader Platform management group
L2 Day-to-day changes Network Contributor, Key Vault Contributor Connectivity and Management subscriptions
L3 Design and major changes Contributor Platform subscriptions

Don’t forget the control plane and data plane split from the Entra vs Azure RBAC post. Key Vault Contributor manages the vault, not the secrets inside it. If someone needs the data, that’s a separate data plane role, so give it its own permission group and decide deliberately who gets it.

I’d also assign at the highest scope that’s genuinely the same job, and no higher. One assignment at a management group is easier to govern than 40 at subscription level, but only if every subscription underneath should get that access. Your management group hierarchy does a lot of the work here.

Why PIM for Groups Needs a Different Shape in Entra

You can’t copy the Azure chain straight into Entra, because role-assignable groups can’t have other groups nested inside them as active members. To assign an Entra role to a group, the group must be role-assignable, so a role group can’t sit underneath it the way it does in Azure.

The simplest answer is to flatten the model for Entra. Create a role-assignable group for each job, give it active assignments to the Entra roles that job needs, and make people eligible for membership. They still get one activation for several roles. The difference is that the group is doing both jobs.

The group has to be made role-assignable when you create it. You can’t convert an existing group later, so plan this before you start building.

There are three more things to get right here:

  • Require approval for groups that elevate into Entra roles. Microsoft recommend this because, on its own, activation only proves someone can sign in as that user. If an admin can’t assign roles but can reset an eligible user’s password, they could sign in as that user and activate the group themselves. With approval, a second person has to agree first.
  • Keep an eye on the limit. You can create a maximum of 500 role-assignable groups in a tenant. Design around jobs, not one group per person or per role.
  • Move activation to the Entra role for M365-sensitive access. For Entra roles with permissions in SharePoint, Exchange or Purview, Microsoft recommend making users active members of a role-assignable group and making the group eligible for the Entra role. Users activate the role they need, so several roles can mean several activations. I’ve sometimes found an InPrivate window helpful when the existing portal session is stale. Service-side propagation can still take time.

Put Activation in One Place

The rule that makes this work is simple: eligibility lives at one layer only.

[INSERT DIAGRAM: pim-activation-paths.png]

The highlighted step is where the user activates. In the Azure and Entra bundle paths, they activate group membership. In the M365 path, they activate the role itself.

It’s easy to stack PIM by accident. If you make a user eligible for a group, and make that group eligible for an Azure role, the user has to activate twice, first for the group and then for the role. That brings back the exact fatigue we’re trying to remove.

In Azure, the role group is the only eligible step. The permission groups hold active role assignments, and engineers inherit those permissions when they activate their role group membership. That control depends on who can change either group’s membership. Restrict who can manage both groups and check both for standing members who can bypass activation.

The same logic applies to nesting across PIM-enabled groups. One group can be an eligible member of another, even a role-assignable one, but the user activates that membership themselves. It only applies to that user, not the whole group, and it’s still a second activation if they also had to activate the first group. It’s useful in the right place, but it isn’t a way to make Entra behave like Azure.

One thing to tell your engineers: activation isn’t always instant in practice. PIM adds the membership within seconds, but an application may have cached the old state. If someone activates and still gets access denied, signing out and back in can help. That one line in your runbook will save you a few support tickets.

Activation Settings by Level

Not every level deserves the same friction. If L1 needs an approver every morning, people will find a way around it, and your approvers will start approving without reading. Save the heavy controls for the access that can do real damage. Here’s an example of how that might look.

Level Max duration Authentication Justification Approval
L1 8 hours MFA Yes No
L2 8 hours Phishing-resistant MFA Yes No
L3 4 hours Phishing-resistant MFA Yes Yes
Entra admin groups 2 hours Phishing-resistant MFA Yes Yes

A few details are worth knowing before you set these:

  • Duration: the activation maximum can be set from one to 24 hours. Match it to the job, and remember that people can deactivate early if they’re done.
  • The MFA setting may not prompt. If a user already authenticated strongly in that session, they might not see an MFA challenge. Use a Conditional Access authentication context with an authentication strength to require phishing-resistant MFA. An existing session can already meet that strength. For reauthentication, set the policy’s sign-in frequency to Every time. Microsoft document a 10-minute window in which another PIM activation can reuse that reauthentication.
  • Authentication context only covers the activation. After activating, a user isn’t stopped from using that access from another device or session. To close that gap, scope Conditional Access to the eligible users themselves, for example by requiring a compliant device.
  • Ticket numbers aren’t validated. The ticket field is information only, so nothing checks it against your ticketing system.
  • Have at least two approvers. Microsoft suggest two for redundancy, because one approver on holiday shouldn’t block an incident at 2am.

What Stays Out of the Model

Convenience is the whole point of a role group, which is exactly why your most dangerous roles shouldn’t be in one. One activation that gives you everything is great for a Network Contributor. It’s a terrible idea for Global Admin.

I keep these outside the role group model:

  • Global Administrator and Azure Owner: these get their own separate, more restrictive elevation. If something can change who has access, it shouldn’t arrive as a side effect of someone starting their day. You want to be alerted when someone elevates to Global Administrator.
  • User Access Administrator: this one’s easy to miss, but it can grant access to others, so treat it the same way as Owner.
  • Break-glass accounts: these exist for when Entra, PIM or Conditional Access has gone wrong, so they can’t depend on any of them working normally.
  • Pipelines and automation: PIM is for people. Non-human access belongs with workload identities.

Don’t forget group ownership either. Each PIM-enabled group has two policies, one for membership and one for ownership. An owner can manage who’s in the group, so if the wrong person owns a role group, you’ve given them a quiet route to everything behind it.

The same goes for who can manage the groups. Role-assignable groups are protected, but standard security groups can be managed by more Entra roles, and more roles can change their members’ credentials. Your Azure role groups will usually be standard groups, so be deliberate about who holds those Entra roles. Otherwise, someone with no Azure access at all could give themselves some.

The Part Microsoft Haven’t Made Easy

The model is clean on a whiteboard. Managing it day to day is where PIM for Groups gets frustrating, because the visibility just isn’t there.

It isn’t easy to see which groups are PIM-enabled. In the PIM Groups view I used, ordinary Microsoft 365 groups appeared alongside groups managed in PIM. The view showed names, object IDs and group types, but I couldn’t use it to tell which groups were enrolled. In a large tenant, that’s a very long list to work through.

Looking at a user doesn’t help much either. If someone asks what a user can actually do, there’s no easy place on their account to see the groups they’re eligible for. And because PIM only adds the membership when someone activates, the group’s normal member list won’t show eligible people unless they happen to be activated at that moment.

That leaves going through each group one at a time, opening its assignments and checking who’s eligible. It’s fine for a handful of groups. It’s painful when you’re trying to answer a simple question across a whole estate, and it’s exactly the sort of question an auditor will ask.

The Graph API should be the way around this, and on paper it is. The docs say you can filter eligibility by either a user or a group. In practice, filtering by another user’s principalId gave me a 403, even with Global Administrator active. The Graph permission was consented and checking my own eligibility worked, so this doesn’t look like a simple permissions gap. I’m not the only one to hit this.

Checking your own eligibility works fine:

GET https://graph.microsoft.com/v1.0/identityGovernance/privilegedAccess/group/eligibilityScheduleInstances/filterByCurrentUser(on='principal')

The workaround that worked in my test was querying by group object ID and then filtering the results for the user:

GET https://graph.microsoft.com/v1.0/identityGovernance/privilegedAccess/group/eligibilityScheduleInstances?$filter=groupId eq '00000000-0000-0000-0000-000000000000'

For a report using the group-based workaround, start with your own inventory or query candidate groups. The results show current eligibility. An empty result doesn’t tell you much, because the same calls work on groups that aren’t in PIM. Microsoft also suggest only calling them for onboarded groups to avoid throttling, which is hard when nothing tells you which groups those are.

That’s why I’d build visibility in from the start. Use a consistent naming convention, keep a record of your PIM-enabled groups, and ideally define them in code.

Proving It Works

Building the model is the easy bit. Without regular checks, it drifts back towards the mess you started with, just with more groups.

  • Review the group where people are eligible. Microsoft’s PIM for Groups access review, currently in preview, includes both eligible and active users. A review of a downstream role can identify access through a nested group, but denying the user there doesn’t remove the upstream membership.
  • Set expiry on eligibility. This is the time-bound eligibility I mentioned earlier. Microsoft’s example settings use three months, which gives you a point to decide whether to renew. Assign someone to make that decision and schedule access reviews separately.
  • Keep the logs for longer. The PIM Resource audit log only goes back 30 days. Send your Entra logs to Log Analytics if you need more history.
  • Check for standing access. Regularly look for anyone assigned directly to a role or permission group. That’s the fastest way to spot the model being bypassed, usually by someone with a good reason during an incident.

Also check your licensing early. You need Entra ID P2 or ID Governance covering eligible users, approvers and access reviewers, not only your admins. The PIM for Groups review itself needs ID Governance or Entra Suite, so P2 alone won’t cover it.

Summary

PIM only reduces risk if people keep using it. If activating access is painful enough, the pressure for standing access always comes back, and it usually wins.

PIM for Groups gets you there, as long as the design comes first:

  1. Split who someone is (role groups) from what the access does (permission groups).
  2. Put eligibility at one layer only.
  3. Flatten the model for Entra, because role-assignable groups can’t nest active groups.
  4. Put eligibility on the Entra role itself when following Microsoft’s guidance for roles with permissions in SharePoint, Exchange or Purview.
  5. Match the friction to the risk at each level.
  6. Keep your most powerful roles and break-glass accounts out of the model.
  7. Review the group where people are eligible, and check regularly for standing access.

None of this is a one-off exercise. Treat it like any other part of your platform: give it an owner, and review it on a schedule.

Your subscription could not be saved. Please try again.
Your subscription to deniscooper.co.uk has been successful.

Join Cloud Engineers Who Build Smarter on Azure

Free checklists, practical guides and the latest posts — built for cloud engineers working with Azure and Terraform.

Leave a Comment