Permanent administrator permissions are convenient until they stop being: a leaked token, a compromised laptop, or an account synchronized from AD that “inherited” a critical cloud role. The problem is not only the incident, but the normalization: when being admin is the default state, real control disappears and auditing becomes an exercise in faith.
Just-In-Time (JIT) Access, applied for real, breaks that inertia: privileged access is requested, granted for a limited time, and recorded with context. It is not “removing permissions”; it is designing an operational flow where privilege expires by default and elevation is a traceable event.
What went wrong: permanent admin as the work standard (and the pandemic of synchronized roles)
The typical signal is not a big incident; it is a sum of accepted “shortcuts”: synchronized AD groups that grant Cloud Admin roles, service accounts with broad permissions “just in case,” and teams that share procedures based on static credentials. In that scenario, the day someone needs to revoke access due to an employee departure or suspicion of compromise, they discover that the permission is distributed in too many places.
Synchronizing AD groups into cloud administration roles usually starts as a simplification (“this way we manage everything in one place”) and ends up like a pandemic: inherited memberships, old exceptions, and a chain of trust that extends beyond the original perimeter. The real impact in enterprises is twofold: audits with repeated findings and, most critically, security investigations where it is hard to demonstrate who had what privilege and when.
The pattern repeats: teams want speed and end up paying with exposure. JIT does not eliminate speed; it forces privilege to be a managed resource, not a fixed attribute of the user.
The root cause: static credentials and “being admin” as an identity, not as an event
When the administrator role is tied to identity (I belong to a group, therefore I am always admin), any compromise of that identity becomes catastrophic. In addition, daily work adapts to the permission available: changes are executed “because you can,” not because they are justified or time-bounded.
The operational alternative is to treat privilege as an event: it is requested for a specific task, enabled with explicit duration, and automatically revoked. This changes the internal conversation: it is no longer about who “is admin,” but which tasks require elevation, under what conditions, and for how long.
- Accumulated risk due to continuous exposure: a persistent session or credentials saved in local tools multiply the attack window.
In practice, this translates into incidents that are difficult to contain: even if you block the user, there may be active tokens, exported credentials, or delegated access. JIT reduces that window because the privilege is not available most of the time.
- Auditing without useful context: logs that only say “the admin account did X,” but not why or under what approval.
When privileged access is granted through a JIT flow, the approval and duration become part of the trail: not only what was done, but also the “why” and “who authorized.” This radically changes the ability to respond to an audit and to an incident.
How to do it in practice: JIT in AWS with IAM Identity Center (temporary and traceable permissions)
In AWS, the most realistic path in corporate environments is to centralize human access in AWS IAM Identity Center and deliver privileges via Permission Sets, avoiding IAM users with long-lived permissions for daily administration. The user signs in with SSO and assumes a role in the target account; the resulting credentials are temporary by design.
The important part is not “using SSO,” but designing the permission sets as least privileges and separate elevations. An engineer should not have a permission set equivalent to AdministratorAccess as a permanent state; there should be a daily operations set and another elevation set with a short window, intended for exceptional changes.
- Create separate permission sets: one operational (read + common actions) and another privileged (scoped admin), assigning the privileged one only when the process justifies it.
This prevents the team from working “always as admin.” It also makes it easier to remove the privileged set without interrupting normal work.
- Configure session duration: set the session duration of the privileged permission set to a short window (for example, 1h) so that access expires without intervention.
The key operational change is that elevation is a temporary event, not an indefinite state that someone “forgets” to revoke.
- Validate that access is truly temporary and auditable: check in CloudTrail the STS events and the actions performed under the assumed role, correlating with the SSO user.
To validate it in AWS, verify that the calls appear with an assumed-role (STS) principal and that the SSO origin is identified. In real operations, this validation is what detects the anti-pattern of “we still have admin IAM users in production” because the logs reveal which access path is being used.
Policy example (excerpt) for a privileged permission set that enables IAM but forces you to limit scope by resource where possible (adapt to your reality; the goal is to illustrate the scoping approach):
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "PrivilegedButScoped",
"Effect": "Allow",
"Action": [
"iam:PassRole",
"cloudformation:*",
"ec2:*"
],
"Resource": "*"
}
]
}
This kind of policy is not “perfect” by itself; the practical point is to separate the privileged permission, limit its duration, and force the usual path to be non-admin. Fine hardening (scoping by ARN, conditions, boundaries) is worked iteratively once the JIT flow is accepted by the team.
JIT in Azure with PIM: permanent eligibility, temporary activation (and friction control)
Azure PIM works well when you need to coexist with corporate structures and strict audits: you can leave certain profiles as eligible for privileged roles (not active) and require a temporary activation with approval, ticket, or justification. The difference is critical: the person is not “admin”; they can become admin for a controlled period.
Business value appears when you connect PIM with the day-to-day reality: maintenance windows, on-call rotations, and urgencies. If you force people to request human approval for everything, the team will look for bypass. Instead, if you define activations with short duration, predefined reasons, and approvals only for what is truly sensitive, you reduce friction without handing out permanent privilege.
- Require MFA and justification upon activation: raises the cost of abuse without punishing legitimate work.
In environments where MFA already exists, this adds an auditable “brake” at the right moment: when someone tries to elevate privileges, not when they sign in for normal tasks.
- Limit duration and force expiration: roles active for 30–60 minutes for changes; more time only with an explicit reason.
This reduces the risk of privileged sessions left open for hours, a classic in real operations (especially during incidents) that expands the surface against phishing or malware.
JIT in GCP with IAM Conditions: privileged access conditioned by time and context
In GCP, IAM Conditions lets you get closer to a pragmatic JIT: you do not always need a separate “activation system” to take the first step; you can condition the use of permissions on time windows or context attributes. Done well, it is an effective way to avoid the permanent role “just in case,” especially in teams that work in shifts or with scheduled changes.
The corporate approach usually works when combined with processes: you define powerful roles, but their effectiveness is conditioned. Thus, even if someone keeps an assignment, the permission is not usable outside the authorized window. The real consequence is that a human error (forgetting to unassign) stops being an automatic disaster.
Conceptual example of a time-based condition (the exact syntax may vary depending on the binding and the editor, but the operational pattern is what matters):
expression: request.time >= timestamp("2026-10-28T18:00:00Z") &&
request.time <= timestamp("2026-10-28T19:00:00Z")
The practical validation here is not theoretical: test that outside the window access fails, and inside it works. In enterprises, this is verified with a test user and a representative action (for example, an admin operation in a non-critical project) recording the results in Cloud Audit Logs to confirm that the control applies and is evidenced.
Recommendations for corporate environments
Real JIT Access means that privilege stops being permanent and becomes temporary, requested, and traceable. The first enemy is usually historical convenience: synchronized groups granting admin, accounts with broad permissions, and workflows based on static credentials. Changing it requires designing the “normal” path without admin and making elevation an event with expiration.
At the platform level, the consistent pattern is: SSO and temporary permissions in AWS IAM Identity Center, eligibility with temporary activation in Azure PIM, and conditions that limit the effective use of the permission in GCP IAM Conditions. The technical part is implementable; success depends on the “request permission” flow being operable in real incidents, with controlled friction and clear evidence in logs.
If your organization wants to say goodbye to permanent administrators, the metric that matters is not how many roles you created, but how many critical tasks are already performed via temporary elevation and how many privileged accesses expire on their own without human intervention.
Interested in Cloud Security?
Technical analysis, hands-on labs and real-world cloud security insights.