All chapters
  1. Start hereA valid token is not a permission
  2. Foundations · 1Identity and trust primitives: who is calling, and who checks
  3. Foundations · 2People and identity proofing: accounts, passwords and recovery
  4. Foundations · 3Sessions and browser security: cookies, CSRF, XSS and the BFF
  5. Foundations · 4Authenticators and MFA: passwords, passkeys and phishing resistance
  6. Foundations · 5API keys and application credentials: what a key proves
  7. Foundations · 6Tokens: bearer, JWT anatomy, validation and revocation
  8. Foundations · 7OAuth, OpenID Connect and federation: delegation and login
  9. Authorization · 8Authorization from first principles: subject, action, resource, context
  10. Authorization · 9Access control models: RBAC, ABAC, ReBAC and ownership
  11. Authorization · 10The enforcement architecture: PEP, PDP, PIP and PAP
  12. Authorization · 11Policy as code: versions, tests, engines and decision logs
  13. Authorization · 12Tenant and data isolation: one platform, many brokerages
  14. Authorization · 13Identity governance and lifecycle: joiner, mover, leaver
  15. Authorization · 14Privileged access: standing rights, just-in-time elevation and break-glass
  16. Workloads · 15TLS, PKI and certificates: proving a host, and a client
  17. Workloads · 16Workload and service identity: SPIFFE, mTLS and caller allowlists
  18. Workloads · 17API gateways and zero trust: the edge checks, the service decides
  19. Workloads · 18Event-driven identity: Kafka principals, ACLs and replay
  20. Workloads · 19Cloud IAM and secretless deployment: roles, federation and no stored keys
  21. Workloads · 20External SaaS, webhooks and trust: calls that cross company lines
  22. Workloads · 21Private controlled environments: what private networking does and does not secure
  23. AI-native · 22Authenticating to model providers: keys, gateways and cloud IAM
  24. AI-native · 23MCP identity and authorization: discovery is not permission
  25. AI-native · 24RAG and retrieval authorization: only what this caller may read
  26. AI-native · 25Agents as principals and delegates: whose authority is this?
  27. AI-native · 26Agent-to-agent trust: identity, capabilities and forwarded authority
  28. AI-native · 27Coding agents and CI: repository scopes, OIDC and no production keys
  29. Operations · 28Auditing and observability of access: decisions you can prove later
  30. Operations · 29Threat modeling and testing: the negative tests that prove access control
  31. Operations · 30Operational lifecycles: rotation, revocation and outages
  32. Reference · 31Standards, frameworks and products: what each one is, and what it is not
  33. Reference · 32Architecture decision playbooks: choosing an auth strategy
  34. ReferenceGlossary
  35. AboutAbout this site and its sources
Authorization · 13

Identity governance and lifecycle: joiner, mover, leaver

From the HR record to onboarding, group assignment, access requests, approvals, SCIM provisioning, periodic review and offboarding. Just-in-time provisioning, separation of duties, dormant identities and orphaned service accounts.

You will trace
One person's access from the HR record through request, approval, provisioning and review to removal.
You will enforce
Separation of duties at grant time and at decision time, and say which code refuses what.
You will find
The accounts nobody owns: dormant people and orphan service accounts, before an attacker does.

The insurer's quarterly access review lands on the desk of u-uw-e1, an underwriter in the business unit commercial-east. Most rows are familiar colleagues. One is not: u-uw-old, still active, still a member of grp-uw-commercial-east, which makes it an underwriter of that unit. Its last sign-in was 120 days ago. A second list, of service accounts, shows svc-legacy-export, an account that can export data. Its listed owner is u-uw-w2, an underwriter who left the company this morning.

Nobody made a mistake that anyone can point to. Each grant was correct on the day it was made: someone asked, someone approved, the directory recorded it. Every token those accounts could obtain would pass every check on Tokens, and the policy decision point would treat u-uw-old as an underwriter of commercial-east, because the directory says so. The problem sits upstream of every check this site has taught so far. Access is added by events; it is rarely taken away by events. The directory slowly stops describing the real organization, and every correct authorization decision built on it inherits the error.

This page is about the machinery that keeps the directory true: where facts about people come from, how they become accounts and groups, who may approve what, how access is reviewed, and how it ends.

What identity governance is, in plain words#

The policy decision point answers "may this underwriter decide this submission?" by reading facts: the person's roles, unit and entitlements. Something has to put those facts there, change them when the person changes jobs, and remove them when the person leaves. That something is identity governance: the processes and systems that decide who should have which access, grant it, check it periodically, and remove it.

A tiny example: HR records that u-uw-w3 joins commercial-west on Monday. By Monday morning an account exists, a request for the unit's underwriter group has been approved by someone else, and the directory lists the membership. Nothing in that chain authenticates anyone or decides any request. It prepares the facts that authentication and authorization will later read.

Before AI. A backend engineer has seen all of this as an HR feed into Active Directory, LDAP groups that map to application roles, a ticket to "add me to the underwriting group", a manager who approves it, and a yearly spreadsheet where managers tick the names they recognize. The words have changed little. What changes with agents is the number of non-human identities that need an owner, which this page returns to below.

Diagram: Where access comes from and where it goes · from the HR record to removal

Read left to right. HR is the source of truth for employment and unit. Provisioning creates an empty account; an approved request adds a group; the PDP reads the directory at decision time. The bottom lane is the half teams build last: reviews and HR events that take access away. Nothing in this chain authenticates anyone or decides a request; it prepares the facts that authentication and authorization read.

  1. Access arrives
    1. HR record: The system whose record decides whether a person works here and in which unit.
    2. account created, no groups: Provisioning creates the account in the directory. An account with no groups grants nothing.
    3. request + approval: Access the source of truth cannot know about is requested and approved by a person who is neither the requester nor the beneficiary.
    4. group added: Only an approved request is provisioned. The group maps to a role or an entitlement.
  2. Access is used
    1. PDP reads the directory: The policy decision point reads roles, unit and entitlements when it decides. Governance never decides a request.
  3. Access leaves
    1. mover: old groups removed: A unit change removes the old unit's groups and the decision entitlement in the same step.
    2. review: recertify or revoke: A periodic check that each grant is still needed. Nobody reviews their own access.
    3. leaver: active = false: Deactivation changes the directory at once. Sessions, tokens and caches need their own removal steps.

Read the chain from left to right. The source of truth is the system whose record decides whether a person works here and in which unit: in most enterprises, the HR system. Provisioning is creating, changing and deactivating accounts and memberships in the systems that need them, driven by that source. Requests and approvals add access the source cannot know about. Reviews catch what drifted. The arrows that remove access matter as much as the ones that add it, and they are the ones teams build last.

The smallest primitive: one provisioning message#

The smallest unit of governance is one change to a directory, sent by the system that knows to the system that needs to know. The standard way to send it between products is SCIM, the System for Cross-domain Identity Management. Standard (RFC 7643 and RFC 7644, read 2026-11-18): SCIM defines User and Group resources and an HTTP protocol with /Users and /Groups endpoints; a User has an active attribute, "A Boolean value indicating the user's administrative status", and membership is changed through the Group's members, because a User's groups attribute is read-only.

Here is the deactivation of the leaver, written from RFC 7644 as read today. The host is illustrative and ends in .example; the bearer token is elided. A PATCH body "MUST contain the attribute "Operations"", and a successful PATCH returns 200 or 204:

PATCH /scim/v2/Users/u-uw-w2 HTTP/1.1
Host: directory.insurer.example
Authorization: Bearer <elided>
Content-Type: application/scim+json

{"schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"],
 "Operations": [{"op": "replace", "path": "active", "value": false}]}

HTTP/1.1 204 No Content

Notice what the message does not do. It does not sign anyone out, revoke a token or refuse a request. Standard (RFC 7644): "The SCIM protocol is based upon HTTP and does not itself define a SCIM-specific scheme for authentication and authorization." SCIM moves facts about identities and groups. The application that receives them must act on them: end sessions, stop issuing tokens, and make its authorization read the new state.

What this is not. SCIM is provisioning, not authentication and not enforcement. A user set to active: false by SCIM can still hold a valid session or a self-contained access token until something else ends it. What ends each of them, and how fast, is on Operations; how a token outlives revocation is on Tokens.

The example models that directory in examples/uw-auth/directory.py as ScimStore, "A SCIM-shaped user and group store ... Not a SCIM server." Its GROUP_GRANTS maps groups to what the policy decision point will see: grp-uw-commercial-west grants the role underwriter, grp-uw-deciders grants the entitlement uw.decide. The snippet shows that the directory's answer follows the membership and the active flag, and nothing else. A successful run proves the mapping; it says nothing about tokens already issued.

from directory import ScimStore

scim = ScimStore()
scim.create("u-uw-w3", "commercial-west")
print("after create:  ", scim.grants("u-uw-w3"))
scim.add_group("u-uw-w3", "grp-uw-commercial-west")
scim.add_group("u-uw-w3", "grp-uw-deciders")
print("after groups:  ", scim.grants("u-uw-w3"))
scim.deactivate("u-uw-w3")
print("after deactivate:", scim.grants("u-uw-w3"))
for op in scim.ops:
    print(op)

Run in a scratch copy of the example on 2026-11-18:

after create:   {'roles': [], 'entitlements': []}
after groups:   {'roles': ['underwriter'], 'entitlements': ['uw.decide']}
after deactivate: {'roles': [], 'entitlements': []}
{'op': 'POST /Users', 'id': 'u-uw-w3'}
{'op': 'PATCH /Groups add', 'id': 'u-uw-w3', 'group': 'grp-uw-commercial-west'}
{'op': 'PATCH /Groups add', 'id': 'u-uw-w3', 'group': 'grp-uw-deciders'}
{'op': 'PATCH /Users active=false', 'id': 'u-uw-w3'}

An account that exists has no access. Access arrives with group membership. Deactivation empties the grants even though the groups are still listed, because an inactive user gets nothing. That order, account first and access by membership, is what lets governance reason about access as a set of grants that each have a reason.

The insurance example: a joiner, a mover, a leaver#

People change in three ways, and each one needs its own handling. A joiner arrives and needs access. A mover changes job or unit and needs new access and the loss of old access. A leaver goes and needs all access removed. Together they are called joiner-mover-leaver, often written JML.

examples/uw-auth/lifecycle.py plays all three, plus a review and two detections, as a 24-event script over a simulated clock that starts at 2026-11-18T09:00:00Z. The lifecycle-only accounts u-uw-w3 (the joiner), u-uw-old (dormant) and svc-legacy-export (orphan) exist only in this module; u-uw-w2 is the peer underwriter of the main example, who leaves here. This is this site's own case UW-A17 for the leaver. The agent in the example is a scripted stand-in, so these results show how the access controls work, not how good any model is.

import lifecycle
from clock import iso

out = lifecycle.run()
for i, e in enumerate(out["events"], 1):
    r = e["result"]
    flag = "" if r["ok"] else "  REFUSED"
    print(f"{i:>2} {iso(r['now'])[11:16]} {r['message']}{flag}")
 1 09:00 HR records a joiner u-uw-w3 in commercial-west (source of truth)
 2 09:00 SCIM POST /Users u-uw-w3: account exists, no groups yet
 3 09:00 u-uw-w3 requests grp-uw-commercial-west for u-uw-w3
 4 09:00 refused: the approver may not be the requester or the beneficiary (separation of duties)  REFUSED
 5 09:00 u-uw-w1 approves REQ-1
 6 09:00 SCIM PATCH /Groups add u-uw-w3 to grp-uw-commercial-west
 7 09:00 u-uw-w3 signs in: session, a self-contained token and an opaque token (exp in 900 s)
 8 09:00 directory allows; self-contained token still accepted; introspection says active; policy cache miss
 9 10:00 time advances 3600 s
10 10:00 u-uw-w3 moves from commercial-west to commercial-east: old unit access removed; new access needs a request
11 10:00 directory denies; self-contained token not accepted; introspection says inactive; policy cache miss
12 10:00 u-uw-w2 signs in: session, a self-contained token and an opaque token (exp in 900 s)
13 10:00 directory allows; self-contained token still accepted; introspection says active; policy cache miss
14 10:00 HR records u-uw-w2 as a leaver
15 10:00 SCIM PATCH /Users active=false; session revoked; opaque tokens revoked; self-contained tokens cannot be recalled
16 10:00 directory denies; self-contained token still accepted; introspection says inactive; policy cache hit (STALE)
17 10:05 time advances 300 s
18 10:05 directory denies; self-contained token still accepted; introspection says inactive; policy cache miss
19 10:15 time advances 600 s
20 10:15 directory denies; self-contained token not accepted; introspection says inactive; policy cache miss
21 10:15 u-auditor-1 recertifies grp-uw-deciders for u-uw-w1
22 10:15 u-uw-e1 revokes grp-uw-commercial-east from u-uw-old
23 10:15 dormant (no sign-in for over 90 days): u-uw-old
24 10:15 orphan service accounts (owner gone): svc-legacy-export

The joiner (events 1 to 8). HR records u-uw-w3 first, and only then does SCIM create the account, with no groups. The account is empty on purpose: HR knows the person and the unit, not which systems they need. The request in event 3 is a self-request, which is normal. Approving it yourself, in event 4, is not, and the state machine refuses it. u-uw-w1, an underwriter of the same unit, approves in event 5, and only an approved request is provisioned in event 6. At the check in event 8 the directory allows u-uw-w3 to read commercial-west.

The mover (events 9 to 11). An hour later HR moves u-uw-w3 to commercial-east. The example removes the old unit's group and the grp-uw-deciders entitlement at once, and grants nothing in the new unit: "new access needs a request". That is the design choice that prevents the most common governance failure, described below. At event 11 the directory denies commercial-west.

The leaver (events 12 to 20). u-uw-w2 signs in at 10:00, HR records the departure, and SCIM deactivates the account in the same minute. The directory denies immediately. The token already issued does not care: a resource server that checks only signature and expiry keeps accepting it for 15 more minutes, and a cached policy decision serves a stale allow. This page stops at the directory; the window after it belongs to Operations, which replays these same events.

Review and detection (events 21 to 24). The auditor recertifies u-uw-w1's decision entitlement. u-uw-e1, who knows the commercial-east team, revokes u-uw-old. The dormant scan flags u-uw-old (no sign-in for over 90 days), and the orphan scan flags svc-legacy-export because its owner, u-uw-w2, is no longer active and is not a team.

Diagram: Joiner, mover, leaver · what changes, what the directory says, what still lingers

Rows are the three changes in a person's working life; columns are the HR event, the directory change and what lingers afterwards. Read the last column: a joiner leaves nothing behind, a mover risks keeping old access, a leaver keeps the credentials already issued until something else ends them.

  1. Joiner
    1. hired into commercial-west: HR records the joiner first; nothing is created before the source of truth knows the person.
    2. account, then one approved group: An empty account, then the unit group after a second person approves.
    3. nothing: A joiner has no old access to forget.
  2. Mover
    1. moved to commercial-east: HR records the unit change.
    2. old unit and decider removed: The example removes old-role access in the same step and grants nothing until a new request is approved.
    3. risk: old access kept by accident: Without the removal step, access accumulates move by move; reviews are the safety net.
  3. Leaver
    1. recorded as leaver: HR records the departure; the directory follows within the minute in the example.
    2. active = false, session revoked: SCIM deactivates the account; the example also revokes the session and opaque tokens.
    3. self-contained token until exp, stale cache: A self-contained token is accepted until it expires, and a cached decision serves a stale allow until its lifetime ends.

The diagram puts the three changes side by side. The column to watch is the last one: what still lingers after the directory is correct. For a joiner nothing lingers. For a mover, the danger is old access kept by accident. For a leaver, it is the credentials already issued.

The lifecycle lab#

The lab replays the same 24 events in your browser. Step through them, change the token lifetime and the policy-cache lifetime, and watch the directory, the tokens and the requests change. Who acts at each step is named in the frame.

The recorded run, for a reader without JavaScript (tokens 15 minutes, cache 5 minutes):

EventWho actsRecorded result
Joiner requests the unit group and approves itu-uw-w3refused: the approver may not be the requester or the beneficiary
Approval and provisioningu-uw-w1, then SCIMu-uw-w3 added to grp-uw-commercial-west; directory allows
Mover to commercial-eastHRold unit access removed; u-uw-w3 denied commercial-west
Leaver checked at 10:00Z, right after deactivationsecurity checkdirectory denies; self-contained token still accepted, 15 min left; introspection inactive; policy cache hit, stale
Leaver at 10:05Z and 10:15Zsecurity checkdirectory denies; token accepted until 10:15Z, then expired; cache miss, denies
Access reviewu-uw-e1revokes grp-uw-commercial-east from u-uw-old
Detectionidentity governancedormant: u-uw-old; orphan service account: svc-legacy-export

Separation of duties: the person who asks never approves#

Separation of duties means that one person cannot complete a sensitive process alone: the requester, the approver and the beneficiary are different people, and so are the person whose access is reviewed and the reviewer. A tiny example: u-uw-w3 may ask for underwriter access, but u-uw-w3 cannot approve it. The rule is old and simple; the hard part is where it is enforced.

In the example it is enforced in two different places, by two different pieces of code, at two different moments.

At grant time, in the governance workflow. lifecycle_step refuses an approval when event["approver"] in (req["requester"], req["user"]), and refuses a review when the reviewer is the user being reviewed. These checks protect the directory: they decide which facts may enter it.

At decision time, in the policy decision point. Some duties must stay separate on every request, not only when access is granted. The example's central rule is the series refrain: the model recommends; a person decides. The policy decision point never lets a person record a recommendation or an agent record a decision (pdp.py, rules R-AZ-08 and R-AZ-09). And the assignment check on decision.record keeps the peer underwriter u-uw-w2, a perfectly valid underwriter of the same unit, from deciding SUB-1004, which is assigned to u-uw-w1 (this site's case UW-A09: 403 under authz-2026.11.1, allowed under the older authz-2026.10.3 that lacked the check).

Common confusion. A governance workflow that enforces separation of duties at grant time does not replace a runtime check. If one group grants both "may recommend" and "may decide", no approval workflow stops the same principal from doing both on one submission. Keep incompatible permissions in separate groups, and keep the per-record rule in the policy decision point. The rule's design is on Authorization.

Just-in-time provisioning: an account created at first sign-in#

Not every system receives a SCIM feed. A common alternative is just-in-time provisioning: the application creates the account the first time a person signs in through federation, from the attributes in the assertion or ID token. A tiny example: a brokerage employee signs in to the broker portal through the brokerage's own identity provider; the portal sees a new subject with tenant brk-north and creates the account on the spot.

Pattern: just-in-time provisioning is an architecture choice, not a requirement of OAuth, OpenID Connect or SAML. It is cheap to build and keeps the account list small, because only people who sign in get accounts. Its weakness is the end of the lifecycle. The application learns about a joiner when the joiner arrives, but it never learns about a leaver: the person stops signing in, and nothing else happens. An account created this way needs one of three things to end properly: a deprovisioning feed (SCIM, or the event-driven profile in the advanced notes), a short session with re-validation at the identity provider on every sign-in, or a dormant-account sweep that deactivates accounts unused for a set period.

Plain English. Just-in-time provisioning answers "how does the account appear?". It does not answer "how does it disappear?". Plan that answer before you ship it.

The broker portal in the example takes the opposite route for brokers (accounts tied to a brokerage that the insurer vouches for; see People), which is why tenant membership is a directory fact and never a claim a broker can type.

Dormant identities and orphan service accounts#

A dormant identity is an active account that has not been used for longer than the organization accepts. u-uw-old is the example: active, still an underwriter of commercial-east, last sign-in 120 days ago. Dormant accounts matter because they are credentials nobody watches: a password reused elsewhere, an authenticator on a lost phone, a session nobody would notice. The example's detection rule is one line: active and now - last_login > days * DAY, with 90 days as the threshold (illustrative; the threshold is an organizational choice).

An orphan account is one whose owner is gone. For people this is a leaver who was never deactivated. For service accounts it is more common and harder to see, because a service account has no HR record. svc-legacy-export was created by u-uw-w2 for some export job; when u-uw-w2 leaves, nothing in HR mentions the export job. The example's rule flags a service account when its owner is neither an active user nor a team. The fix it points to is structural: every service account has an owning team, not an owning person, and a team's dissolution is itself a governance event.

Production pitfall. Detection without a decision rule fills a dashboard and changes nothing. Decide in advance what happens to a dormant account (deactivate after notice) and to an orphan service account (disable, then delete after a quiet period if nothing breaks), and who signs off.

Failure mode: the mover who keeps everything#

Picture the insurer without the example's mover rule. u-uw-w3 moves from commercial-west to commercial-east, requests the east group, gets it, and keeps the west group because nobody removes it. A year and two moves later the account is an underwriter of three units and holds uw.decide from a team it left. Every request it makes is authorized correctly against the directory. The directory is wrong. This slow accumulation is often called privilege creep, and it is the reason access reviews exist.

The example closes it at the source: a move removes the old unit's groups and the decision entitlement in the same step, and every new grant needs a new request (event 10). The cost is a day of friction for the mover. This site's recommendation: treat a move as a leave plus a join for everything tied to the old role, and keep only what the new role re-requests.

Architecture choice: how much governance machinery#

SituationSimplest credible choiceGrow whenAlternatives
One application, a few staffAccounts in the identity provider; roles assigned by an administrator; a written leaver checklistmore than one application, or a second administratornone needed yet
Several applications, one workforceGroups in the identity provider mapped to application roles; SCIM to each application that supports it; HR-driven joiner and leaver eventsauditors ask who approved each grant; access requests become ticketsper-application user stores (each one is a leaver risk)
Regulated workforce, many systemsAn identity governance product: access request catalog, approval chains, periodic reviews, separation-of-duties rules, reportsnon-human identities outnumber people; agents get their own identitiesa home-grown workflow on the ticket system
Customers' users (B2B tenants)Federation with the customer's identity provider, with just-in-time provisioning plus a deprovisioning feed or short re-validationcustomers demand SCIM; tenant administrators manage their own userstenant-managed local accounts

The trigger to grow is not company size. It is the moment the question "who approved this access, and is it still needed?" cannot be answered from a record.

Standards and products for this chapter#

Standard (RFC 7643, RFC 7644, read 2026-11-18): SCIM core schema and protocol, Proposed Standards from September 2015. The User schema's externalId is set by the provisioning client and serves as the join key back to the source system; entitlements and roles exist as User attributes; PATCH follows JSON Patch with add, remove and replace, and each PATCH is atomic.

Standard (RFC 9865 and RFC 9967, read 2026-11-18, SURPRISING and confirmed on a second fetch): both update RFC 7643 and RFC 7644. RFC 9865 (October 2025) adds cursor-based pagination. RFC 9967 (May 2026), "SCIM Profile for Security Event Tokens", defines SCIM security events "to enable the asynchronous exchange of messages between SCIM service providers and receivers", including urn:ietf:params:scim:event:prov:deactivate. A ten-year-old protocol gained an event-driven mode this year; check whether your products implement it before designing around it.

Guideline (NIST SP 800-63-4, read 2026-11-18): the guideline's stated scope is "the identity proofing, authentication, and federation of users". It is the source for proofing and authenticator assurance (see People and Authenticators); the volumes read here do not prescribe access-request or review processes. Guideline (OWASP Authorization Cheat Sheet, read 2026-11-18): "Enforce Least Privileges" is its first heading, and governance is how least privilege survives people changing jobs.

Product (Microsoft Entra ID Governance, as documented on 2026-11-18): Privileged Identity Management, part of Entra ID Governance, lists "Conduct access reviews to ensure users still need roles" among its features. Privileged roles are the next page. Other identity governance products exist; this site describes only what it read.

In a coding agent. A coding agent's repository access is an identity with a lifecycle too. A repo-scoped GitHub App installation has an owning team and appears in the same review as people; a personal access token belongs to one person and leaves with them, which is a reason to prefer the App. When a developer leaves, the leaver checklist covers their tokens and the agent configurations that used them. Depth is on Coding agents.

Security notes#

Monday checklist#

Exercises#

Exercise 1. A team lead requests grp-uw-deciders for a new underwriter and approves it in the same form, because "I am their manager". What does the example do, and what should a real workflow do?

AnswerRequester cannot approve; route to another approver

The example refuses it: the approver may not be the requester or the beneficiary. A real workflow routes the request to a second approver (another manager, or the data owner of the unit) and records both names.

Exercise 2. The broker portal uses just-in-time provisioning from each brokerage's identity provider. A brokerage employee leaves. Which three mechanisms could end their access, and which one does just-in-time provisioning provide by itself?

AnswerA deprovisioning feed, re-validation, a dormant sweep; none by itself

A deprovisioning feed from the brokerage (SCIM or SCIM events), short sessions that re-authenticate at the brokerage's identity provider, or a sweep that deactivates unused accounts. Just-in-time provisioning provides none of them; it only creates accounts.

Exercise 3. After the review, u-uw-old has no groups but is still active. Is that safe?

AnswerSafer, not finished

It has no underwriter role, so the policy decision point denies unit data. But an active account can still sign in, hold a session and request access again. If the person no longer needs the account, deactivate it; if they do, find out why it was unused for 120 days.

Advanced perspective#

From polling to events: RFC 9967 and Shared SignalsDeprovisioning that arrives in seconds instead of on the next sync

Classic SCIM is push-by-request: the provisioning client calls the application when something changes, or the application polls. Delivery failures leave a leaver active until the next full sync. Standard (RFC 9967, May 2026): SCIM security events ride on Security Event Tokens (RFC 8417), with provisioning event types such as urn:ietf:params:scim:event:prov:create:{notice|full}, ...:prov:delete, ...:prov:activate and ...:prov:deactivate, so a receiver can react to a deactivation without polling. Standard (OpenID Shared Signals Framework 1.0 and CAEP 1.0, listed Final on openid.net, read 2026-11-18): a transmitter sends events about subjects to a receiver over a stream; CAEP defines session-revoked ("signals that the session identified by the subject has been revoked") and credential-change, among others. Governance tells the directory; these events tell every application that relies on it. The operational side is on Operations.

Groups, app roles and where fine-grained access livesCoarse in the directory, per-record in the application

A tempting design puts every permission in directory groups: one group per submission, per tenant, per action. It fails twice: tokens cannot carry thousands of groups, and governance cannot review them. Product (Microsoft Entra ID, as documented on 2026-11-18): above 200 groups a JWT carries no groups claim, only an overage pointer; app roles are app-specific while groups are tenant-wide, and "an app using groups for authorization will break in the next tenant"; Microsoft advises keeping "finer-grained resource permissions in your application's authorization data". The example follows that split: the directory holds underwriter and uw.decide; the assignment of SUB-1004 to u-uw-w1 is application data read by the policy decision point. Governance reviews the coarse grants; the application's own data and tests keep the fine ones correct.

Why access reviews get rubber-stamped, and what helpsFewer, better-chosen questions

A reviewer handed 400 rows recertifies all of them; the review produces a signature, not a decision. Three changes help. Ask the person who knows the work (in the example u-uw-e1 reviews the east unit, not a central administrator). Show evidence on each row: last use, last sign-in, who approved it and why. And review risk first: decision entitlements, privileged roles and service accounts every cycle, ordinary read access less often. Review results are themselves audit records, so a revocation that never reaches the target system shows up as a mismatch on the next cycle. None of these cadences is set by a standard read here; they are organizational choices.

Agents are identities with ownersNon-human identities join the same lifecycle

The underwriting agent wl-underwriting-agent has its own workload identity (spiffe://insurer.example/ns/uw/sa/underwriting-agent) and scopes uw.read uw.recommend. It has no HR record, so it needs what a service account needs: an owning team, a reason, a review, and a removal path when the workflow is retired. Products are starting to treat agents as governed identities. Product (Microsoft Entra, as documented on 2026-11-18): PIM lists "Govern Azure resource access for agents" as a preview capability, assigning eligible roles "to agents and agent identities", and Conditional Access lists agents as a preview signal. Whatever the product, the governance question is the same as for svc-legacy-export: who answers for this identity when its creator leaves? How an agent's authority is narrowed per task is on Agents.

In one breath#

Every authorization decision reads facts from a directory, and identity governance is what keeps those facts true: HR as the source of truth, accounts created empty, access added by approved requests and removed by moves, departures and reviews. Separation of duties belongs in code twice: in the workflow that grants access and in the policy decision point that refuses incompatible actions on each request. SCIM carries the changes between systems; it authenticates nobody and enforces nothing. Dormant people and orphan service accounts are what the lifecycle leaves behind when removal is not an event.

The directory now says who should be an underwriter, and the review removes what drifted. One kind of access is still dangerous even when the directory is correct: the administrator who can change the directory, the policy or the keys. Privileged access asks how to give that power only for an hour, only with a second person's approval, and with a record of every use.