Guide
What is Just-in-Time Access?
Just-in-time access grants privilege only for a defined task and time window, then removes it automatically when the window expires.
No credit card · Business email · Limited trial capacity
Just-in-time access grants privilege only for a defined task and time window, then removes it automatically when the window expires. It is a response to the risk of standing privilege: accounts and roles that stay powerful even when nobody is actively using them. JIT does not mean slowing teams down. It means making the temporary grant explicit, approved, logged and revocable by design.
The standing privilege problem
Permanent access is convenient until it becomes unmanageable. Engineers change teams, vendors finish projects, emergency grants remain in place, and broad cloud roles spread through copy-pasted policies. Even when each grant was reasonable at the time, the accumulated result can give many identities more power than they need. Attackers and insiders do not need a new vulnerability if dormant privilege already exists.
JIT changes the default. Instead of asking why a user should not have a powerful role, it asks what work requires the role right now. The answer becomes the request: target, action, duration, approver, ticket and risk context. When the task ends or the timer expires, the grant ends too.
What a good JIT request contains
A useful request is specific. It identifies the person, the target system, the access level, the reason and the requested duration. For production systems it should also include a ticket or change reference where required. Approvers need clear context: whether the requester normally works on the system, whether the access is outside business patterns, whether the target is sensitive, and whether related cloud entitlements create additional risk.
The duration should be long enough for the task and short enough to avoid idle privilege. Some tasks need only minutes. Others, such as maintenance windows, may need several hours. The key is that expiry is automatic and enforced by the system, not left to a manual cleanup checklist.
Approval patterns
JIT approvals can be handled in a web application, in ChatOps tools such as Slack or Microsoft Teams, or through ITSM ticket validation in systems such as ServiceNow and Jira. Chat approvals are useful when teams already coordinate incidents in chat, but they should not be isolated messages. The approval should link to the policy, target, grant and recording so that audit evidence stays connected.
Some requests can be policy-approved after checks pass. For example, a low-risk maintenance role might require MFA, an active ticket and membership in an on-call group. Higher-risk grants should require a second person. Break-glass grants need a path that works during emergencies, but they should be visible, short-lived and reviewed afterward.
Session brokering and token handling
JIT works best when the system grants access without exposing long-lived secrets. A broker can connect the user to SSH, RDP, databases or Kubernetes after approval. For cloud roles, the system can execute a grant or membership change for the duration. For CI/CD, OIDC federation can issue short-lived credentials to a pipeline without storing a static secret. These patterns reduce the value of stolen passwords and reduce the need for operators to copy secrets into terminals.
Recording, monitoring and expiry
JIT is stronger when every grant produces evidence. A complete trail includes the request, approver, MFA result, policy decision, target, start time, end time, revocation and session recording where applicable. Live view and session sharing can help responders supervise high-risk work. Searchable recordings make it easier to answer questions after an incident or during an access review.
Expiry is not just a timestamp in a log. It must actively remove the grant. That might mean dropping a group membership, ending a session, revoking a checked-out credential, removing local administrator rights or closing a cloud role assignment. If a target is offline, the design should still ensure local temporary grants cannot last forever.
Design choices and trade-offs
Teams can implement JIT at different layers. Network-level access can reduce exposure but may not know which administrative action happened. Identity-level access can grant precise roles but may not record a shell or database session. A brokered session can record the privileged activity but must support the protocols teams use. Most organisations need a combination, with policy deciding which layer is right for each target.
Do not make the first rollout too broad. Start with a few high-value targets, define request templates, connect MFA and approvals, and prove that expiry is reliable. Then extend the model to vendors, break-glass workflows, machine identities and local admin elevation.
Common mistakes
The first mistake is treating JIT as a manual ticket process. If a ticket approves access but nobody enforces expiry, the result is still standing privilege. The second mistake is making approvals too vague. Approvers need target and risk context. The third mistake is ignoring service accounts and pipelines. Static machine credentials can be as sensitive as human admin accounts. The fourth mistake is hiding the recording policy from users. Notices and internal policies should explain when privileged sessions are recorded and who may review them.
Policy examples
A database owner request might require the requester to select a specific database, provide a ticket and pass MFA before a second person approves. A Kubernetes production namespace request might require on-call membership and a shorter duration. A vendor request might require an account expiry date, a named sponsor and recorded sessions only. These examples show why JIT is not a single button; it is a policy model that adapts to risk while keeping the same evidence chain.
Teams should also define denial paths. If a request lacks a ticket, asks for an excessive duration or targets a system outside the requester's role, the approver should be able to reject it with a reason. That reason is useful later because it explains why access was not granted and can reveal training or process gaps.
How Access Dealer fits
Access Dealer supports JIT requests with approvals in the web application, Slack, Microsoft Teams and ITSM ticket validation through ServiceNow or Jira. It brokers SSH, RDP in the browser, PostgreSQL, MySQL, Microsoft SQL Server and Kubernetes sessions through an outbound-only broker. Grants can target Azure RBAC roles, Microsoft Entra ID groups, Active Directory groups and local accounts. Mandatory MFA applies using built-in TOTP, email codes, WebAuthn/passkeys or supported external MFA such as Duo and RADIUS.
For local administrator scenarios, Access Dealer Elevate grants temporary sudo, Administrators or macOS admin rights after a second person approves and removes the rights automatically on expiry. CIEM analysis provides context on cloud entitlement paths so approval decisions are not blind to escalation risk. The result is a JIT model that ties the reason, approval, session and revocation together.