Independent analysis by NHI Mgmt GroupSource article: PlainID, “Why Static Access Checks Are Not Enough for Zero Trust Access Control” (November 9, 2026)

TL;DR: PlainID describes how zero trust programs still leave a gap when they stop at sign-in, because static authentication, device checks and ZTNA do not re-evaluate what a verified identity can do inside the session. Runtime authorization shifts the decisive control to each request, where data sensitivity, behavior and context determine access.


At a glance

What this is: NHI Mgmt Group's analysis, drawing on PlainID's blog post: Zero trust that stops at sign-in leaves a session gap, and runtime authorization closes it by deciding every request against live context.

Why it matters: This matters because IAM and security teams need to control what an authenticated identity can do after login, especially for sensitive data, regulated records and high-volume sessions.

👉 Read PlainID's analysis of zero trust access control and runtime authorization


Context

Zero trust often fails at the point where a session becomes trusted for the rest of its life. Authentication, device posture and network access can all succeed while the user or workload still gains far more data access than the current moment justifies.

Runtime authorization closes that gap by moving the access decision to the resource and evaluating each request in context. That matters for regulated data, shared platforms and zero trust identity programmes that still rely on one-time checks.


Key questions

Q: What should teams do first when zero trust stops at sign-in?

A: First, separate authentication from continuous access enforcement. If zero trust ends at sign-in, teams should add step-up checks, session re-evaluation, and policy decisions at request time, based on device posture, user risk, location, and resource sensitivity. That prevents a valid login from becoming standing access for the whole session.

Q: Why do valid sessions still create identity risk?

A: Because session validity only proves the account authenticated successfully. It does not show whether the activity was expected, proportionate, or appropriate for the identity’s assignment. Risk increases when organisations cannot explain why the identity, device, resource, and business purpose fit together at the time of action.

Q: Why do modern Zero Trust programmes need runtime authorization?

A: Zero Trust depends on continuous verification, but verification is incomplete if access decisions are made only at provisioning time. Runtime authorization gives teams a way to enforce purpose, context, and duration at the moment of action. That is what makes zero standing privilege operational rather than aspirational.

Q: What is the difference between ZTNA and runtime authorization?

A: ZTNA controls whether a user or device can reach an application, usually by replacing broad network reach with app-specific access decisions. Runtime authorization decides what an authenticated session, user, or agent may do inside the application after entry, using policies such as RBAC, ABAC, and token-scoped permissions.


Technical breakdown

Why sign-in controls do not govern session behaviour

Sign-in controls answer a narrow question: is this identity and device acceptable at the moment of entry? They do not continuously govern what happens later in the session. Once a token is issued, the application or gateway often treats the session as trusted until expiry, even if the user's behaviour changes or the request pattern becomes abnormal. That is why a clean MFA result and a healthy posture score can still lead to excessive data exposure. Zero trust at the front door is necessary, but it is not the same as per-request authorization.

Practical implication: Design access decisions to continue after login, not just at authentication time.

How runtime authorization evaluates every request

Runtime authorization makes a fresh decision for each access request using live context such as role, data sensitivity, location, time and behaviour. Instead of granting a broad permission once and reusing it everywhere, the policy evaluates the specific action against the current conditions. That architecture is usually placed at the policy decision point and policy enforcement point near the resource, which keeps the control close to the data rather than in a separate sign-in layer. The result is narrower access without forcing every application to build its own logic.

Practical implication: Place decision logic where the data lives so each request can be judged on current context.

Why row and field controls matter in zero trust

Zero trust becomes materially stronger when access is evaluated at row, column or action level, not only at the application boundary. A claims platform, for example, may be legitimate to open, yet the user should not be able to bulk export every record or query fields that carry more sensitivity than the task requires. Row and field controls let policy distinguish between viewing a record and extracting sensitive attributes from it. That distinction matters because attackers who inherit a valid session usually exploit the difference between screen access and data access. Read Zero Trust for AI Agents.

Practical implication: Use fine-grained policy to separate application reach from sensitive data exposure.


Threat narrative

Attacker objective: The attacker aimed to exfiltrate large volumes of regulated claims data, including medical codes and bank details, through a trusted session.

  1. Entry occurred through a valid authenticated session on a managed device, where MFA and posture checks were already satisfied.
  2. Escalation followed when a malicious browser extension stole the session token and reused the existing trust context.
  3. Impact came from high-volume data extraction across tens of thousands of claim records before any request-level control intervened.
  • Dropbox Sign breach 2024: A compromised back-end service account gave attackers Dropbox Sign customer data, including API keys, OAuth tokens and MFA information.
  • Uber breach 2022: A contractor's stolen password and MFA fatigue gave a Lapsus$-linked attacker Uber's internal tools; Uber rotated keys to many services.

Read and download The State of NHI & AI Agent Breach Report 2026, covering 200+ breaches impacting Non-Human Identities including AI Agents.


NHI Mgmt Group analysis

Static access checks turn zero trust into an entry control, not an operating model. Authentication, device checks and ZTNA can all be correct while the session still drifts far beyond the approved task. The insurer scenario shows that the control failure is not entry validation but the absence of a decision layer that keeps watching the request path. Practitioners should treat sign-in as the start of governance, not the end of it.

Record-level authorization is now the control that determines whether zero trust is actually measurable. The gap is not abstract: once a session can pull rows, columns or exports without re-evaluation, policy becomes a one-time assertion rather than an active control. That is why zero trust programmes that stop at application access often leave the data layer exposed. Security leaders should measure how far policy reaches beyond authentication and gateway enforcement.

Standing privilege is the hidden debt inside apparently successful zero trust programmes. The current model still assumes access can be judged once and reused later, even though business context changes throughout the day. That assumption collapses when the session itself becomes the threat surface, because the access that was justified at 9:02 may be unjustified by 2:15. Identity teams need to treat persistence of privilege as a governance flaw, not just an implementation detail.

Authorization graphs and policy visibility are becoming board-level evidence, not technical extras. When policy lives across applications, gateways and custom code, no one can answer who had access to what without a forensic project. Centralised decision records make access explainable and auditable across regulated systems, which changes how auditors, regulators and business leaders assess control maturity. Practitioners should make decision evidence as visible as the access itself.

Runtime authorization is the named concept this market now needs: access control that decides every request against live context. That concept matters because it shifts zero trust from static trust placement to continuous policy enforcement. It also gives security teams a vocabulary for separating authentication success from authorization sufficiency. The implication is straightforward: programmes that cannot express per-request policy are still relying on legacy trust assumptions.

From our research library:

What this signals

Zero trust maturity now depends on whether authorization is continuous or merely implied. Programmes that keep access decisions at sign-in will keep inheriting the same failure mode: a valid session becomes a standing permission set. The practical test is whether the control can still change access after the user is already inside the application.

Per-request control is becoming the dividing line between compliance posture and operational security. Regulators care about who accessed what, when and under which policy, but that evidence is only useful if the policy itself can change with context. The reader's programme should therefore treat policy visibility and decision logging as core control capabilities, not after-the-fact reporting.

Session trust debt will keep growing wherever identity and data controls remain separated. The more sensitive the data, the more costly it becomes to assume that one clean authentication event can justify the rest of the session. Enterprises should expect the strongest pressure first in regulated data environments, where a stolen token can outlive the condition that made it valid.


For practitioners

  • Define request-time policy for sensitive data Identify the data sets where a valid session should not equal unrestricted access, then express limits using role, sensitivity, time and behaviour.
  • Move enforcement closer to the resource Place policy decision and enforcement where the application, API or data platform can evaluate each request before release.
  • Separate application access from data access Set different rules for opening a system, reading a record and exporting high-value fields so the session cannot inherit blanket trust.
  • Build audit evidence from authorization decisions Record each policy decision in a form that auditors and investigators can query without reconstructing logic from scattered logs.

Key takeaways

  • Zero trust fails when the control stack stops at entry and never re-evaluates what a session can do once it is inside the application.
  • The central weakness is not authentication itself but the persistence of broad permissions after login, which lets stolen sessions inherit more access than they should.
  • Per-request authorization changes the governance model from static trust to live decisioning, which is the only way to shrink the blast radius of a compromised session.

Related NHI Mgmt Group resources: Ultimate Guide to NHIs: Standards · Zero Trust Identity Guide · Zero Trust for AI Agents · Dropbox Sign breach 2024


Standards & Framework Alignment

This section maps relevant standards and security frameworks to the operational risks and controls described in this guidance.

OWASP Non-Human Identity Top 10 and MITRE ATT&CK address the attack and risk surface, while NIST CSF 2.0, NIST Zero Trust (SP 800-207) and NIST SP 800-53 Rev 5 set the governance and control requirements practitioners need to meet.

FrameworkControl / ReferenceRelevance
OWASP Non-Human Identity Top 10NHI-05 — Overprivileged NHIRuntime authorization is needed where sessions and non-human actors carry broader access than the current request requires.
Recommendation — Reduce standing access and enforce request-time limits for identities that can reach sensitive data.
NIST CSF 2.0PR.AA-05 — Access Permissions, Entitlements and AuthorizationsThe article centres on authorization decisions, entitlements and live enforcement inside zero trust.
Recommendation — Apply PR.AA-05 to evaluate and constrain permissions at the point of each access request.
NIST Zero Trust (SP 800-207)Policy Enforcement Point; Policy Decision Point — Policy Enforcement Point; Policy Decision PointNIST SP 800-207 is directly referenced as the architecture for placing decisions near the resource.
Recommendation — Place policy decision and enforcement components at the resource so access stays context-aware.
NIST SP 800-53 Rev 5AC-6 — Least PrivilegeThe post shows how broad, persistent session permissions violate least privilege in practice.
Recommendation — Limit each session to the minimum access needed and re-evaluate permissions as context changes.
MITRE ATT&CKTA0006; TA0010 — Credential Access; ExfiltrationThe attack chain uses token theft followed by large-scale data exfiltration from a trusted session.
Recommendation — Map token theft and bulk record theft to credential access and exfiltration detections.

Key terms

  • Zero Trust Architecture (ZTA): Zero Trust Architecture is a security model that assumes no user, device, workload, or network path should be trusted by default. It continuously verifies identity, context, and policy before allowing access, using least privilege, strong authentication, and segmentation to reduce blast radius and limit lateral movement.
  • ZTNA: Zero Trust Network Access is a remote access model that grants users or devices access only after identity, context, and policy checks are satisfied. It reduces implicit trust by exposing specific applications or resources instead of the broader network, which makes it useful for telework, contractor access, and other situations where least privilege matters.
  • Conditional Access: Conditional access is a policy model that decides whether an action should proceed based on context such as posture, resource sensitivity, timing, and scope. For AI agents, it must be evaluated at request time so a valid credential does not automatically equal permitted behaviour.
  • Policy decision point: A policy decision point evaluates contextual rules and returns an access decision that enforcement points can act on. It separates authorization logic from application code, which helps teams manage tenant rules, resource ownership, and risk signals consistently.

What's in the full article

PlainID's full blog post covers the operational detail this post intentionally leaves for the source:

  • Survey findings on how many zero trust programmes still omit runtime authorization and where visibility breaks down
  • Policy design examples for row, column and action-level enforcement across applications, APIs and data platforms
  • Implementation detail on extending identity and access decisions into AI agents, gateways and data stores
  • Operational guidance on measuring authorization maturity before and after rollout

👉 PlainID's full post covers runtime policy design, audit visibility and deployment details across applications and data platforms.

Deepen your knowledge

NHI governance, identity lifecycle management, and workload identity security are core topics in our NHI Foundation Level course, the industry's only accredited NHI security programme. If you are building or maturing an IAM programme, it is worth exploring.
NHIMG Editorial Note
Published by the NHIMG editorial team on November 16, 2026.
NHI Mgmt Group, the independent authority on Non-Human Identity, IAM, and Agentic AI security. nhimg.org