# Approval Policies

Define a named, org-wide set of rules for who has to approve a request, and attach it to access rules, tools, and runbooks

A policy is an ordered list of rules. Each rule pairs a condition with an approval
requirement, using the same profile rules, IdP groups, and approver settings as an access rule.
Risotto evaluates rules top to bottom and applies the first one that matches.

Without a policy, "contractors need IT approval, everyone else needs none" takes two access rules
on the same application, with every fulfillment setting duplicated so that only their conditions
and approvers differ. A policy called "Contractor approvals" holds that logic once, and any number
of access rules point at it.

You can attach a policy to an [access rule](#attaching-a-policy-to-an-access-rule), a
[tool](#attaching-a-policy-to-a-tool), one [tool reference in a runbook](#a-different-policy-for-one-tool-reference),
or a whole [runbook](#attaching-a-policy-to-a-runbook).

To watch one policy built, tested, and attached to an access rule and a tool, see the [three-minute video](https://www.tryrisotto.com/docs/guides/approval-policies-video). For six advanced cases (one policy for several audiences, approvers from the profile, a fallback when no one responds, the access rule around a policy, policies on tools, and what happens when the identity provider can't be reached), see [Approval policies: advanced use cases](https://www.tryrisotto.com/docs/guides/approval-policies-advanced-video).

## How a policy resolves

Rules are evaluated in order, top to bottom, and the first match wins.

A requestor that no rule matches is **denied**. The policy is the whole statement of who may
request the access: if the rules do not cover a person, that person cannot request it. Risotto
records the refusal reasons on the ticket and the agent escalates it to a human. An empty policy
denies everyone.

To let everyone else through, add a last rule with no condition. A rule with no condition matches
everyone, so it must be the last rule: every rule below it would be unreachable. Its requirement
may be **No approval needed** or an approval chain, whichever you intend for people the other
rules miss.

Order still matters when conditions overlap. A rule matching everyone in Engineering, placed
above a rule matching engineering managers, means the manager rule never fires. Put the most
specific rules at the top.

> **Note:** Until September 2026, every policy ended in a required **default rule** that
> matched everyone, and a requestor the other rules missed got whatever the
> default said. Existing policies kept that behavior: the old default became an
> ordinary last rule named **Default rule**. Deny-by-default applies only when a
> policy has no such catch-all rule, for example after you delete it.

## Rule conditions

Conditions read from your identity provider.

**Requestor profile** conditions test identity provider profile fields: department, title, cost
center, or any other field, named as your provider spells it. Field names and values are
case-sensitive. Conditions can be grouped and combined.

For how to name a custom attribute from Okta, Google Workspace, or JumpCloud, see [Requestor profile](https://www.tryrisotto.com/docs/dashboard/applications/access-rules#requestor-profile).

**Requestor group membership** restricts a rule to members of specific identity provider groups.

A rule may use either, or both. With both, the user must satisfy both to match.

## Approval requirements

Each rule carries the same approval settings available directly on an access rule. With
**Require approval** selected:

- **Approval steps**: each step has a type and a value. The types are **Direct message** (a person
  by email), **IdP group**, **Channel** (a Slack channel), **Related IdP user** (the person named
  in a field of the requesting user's profile, for example their manager), and **Business owner
  of the app** (the business owner email set on the app; access requests only). Click **Add
  approval step** to add a step. For the details of each type, see
  [Approvals](https://www.tryrisotto.com/docs/dashboard/applications/access-rules#approvals).
- **Ask steps** and **and require**: with two or more steps, choose **In order** or **At the same
  time**, and **Any one** or **All of them**. With one step, the header reads **One approval
  step**.
- **If no one responds**: ask one more approver, then escalate the ticket. See
  [If no one responds](#if-no-one-responds).
- **Require a reason on denial**: the approver must say why before a denial is accepted.
- **Prevent self-approval**: the user the request is for cannot approve it, even if they are
  named as an approver.
- **If no one responds** (default: off): what Risotto does when the approvers do not answer. See
  [If no one responds](#if-no-one-responds).

> **Warning:** **Prevent self-approval** compares each approver to the user the request is
> for, not to the person who opened the request. For an access request, this is
> the person who receives the access. For a tool or runbook approval, this is
> the requestor. A manager who requests access for a direct report can approve
> that request. The direct report cannot approve it, even when someone else
> opened the request. A skipped approver is not listed on the access request, so
> a chain of two approvers can read as one.

If **Prevent self-approval** skips every approver, Risotto cancels the approval request and escalates the ticket. The escalation reason starts with "Approval routing failed". The same happens when the chain requires **All of them** and one of the approvers is the user the request is for. Add a second approver, or leave **Prevent self-approval** off for that rule.

If the user the request is for clicks **Approve** on a request that reaches them, for example through a Slack channel, Risotto does not record the approval. Only that user sees the reply "You cannot approve your own access request. Another approver will need to review this request." The request stays open for the other approvers.

When a policy rule has **Prevent self-approval** on, its summary reads "The user the request is for can't approve it."

> **Note:** With **All of them**, a skipped approver leaves the chain unsatisfiable, so
> Risotto stops and escalates the ticket to a human instead of collecting
> approvals. With **Any one**, the request goes to the approvers who remain, and
> Risotto escalates only when the requester was the only one.

Slack messages, [reminders, and escalations](https://www.tryrisotto.com/docs/dashboard/settings/notifications#next-approval-delay)
behave exactly as they do for approvals configured directly on an access rule. A policy changes
where the approval requirement comes from, not how approvals are collected.

### If no one responds

Turn on **If no one responds** to ask one more approver when nobody answers, and then escalate
the ticket:

1. In **After**, set how long to wait, then choose the extra approver under **also ask**.
2. In **If still no answer after**, set the second wait. When it ends, Risotto escalates the
   ticket.

Each wait is in minutes or hours, from 15 minutes to 7 days. A new path starts at 48 hours and
24 hours. The rule's summary reads, for example, "If no one responds in 2 days, also ask
*approver*. Escalate the ticket 1 day after that."

With two or more steps asked **In order** and **Any one**, the switch is off and reads "In order
chains pass to the next step. Add the fallback as the last step." Such a chain already passes an
unanswered request to the next step, so add the extra approver as the last step instead.

### If no one responds

Turn on **If no one responds** to ask one more approver when a request waits too long, and then
to escalate the ticket. The switch is on each rule that has **Require approval**, and on the
approvals of an access rule. Set two waits:

1. **After** a wait (default: 48 hours), **also ask** a fallback approver. Choose the fallback
   approver like any other approver.
2. **If still no answer after** a second wait (default: 24 hours), **then** **Escalate the
   ticket**. This is the only final action.

Each wait can be from 15 minutes to 7 days. Risotto checks waiting requests every 5 minutes, so a
step can start up to 5 minutes late. The first wait starts at the last time Risotto asked an
approver. The second wait starts when Risotto asks the fallback approver.

- The fallback approver gets a card that starts with "Waiting" and names how long the request
  waited and who did not answer.
- An approval from the fallback approver completes the request, also when every approver must
  sign off.
- At the final step, the request expires and Risotto escalates the ticket through the
  [escalation routing](https://www.tryrisotto.com/docs/dashboard/settings/departments#escalation-routing) of the department.
- If Risotto cannot ask the fallback approver (for example, the person is not in Slack or
  Microsoft Teams, or is the requester), it escalates the ticket at once.
- When you add or change the path, the change also applies to requests that already wait.

You cannot turn on **If no one responds** for a chain of two or more approvers that are asked
one at a time and where any one approver is enough. Such a chain already passes to the next
approver by itself. Add the fallback as the last approver of the chain instead.

The policy summary shows the path, for example "If no one responds in 48 hours, also ask
\<approver>. Escalate the ticket 24 hours after that."

## Creating and editing policies

Policies live in a shared library under **Settings → Approval Policies**. Only Org Admins see this
page.

The **Used In** column of the policy list shows how many access rules, runbooks, tools, and
automations use each policy, or **Not used**. A runbook counts when the policy is on the runbook
itself or on one of its tool references. On a policy's page, the button beside the name (for
example **Used in 2 runbooks**, or **3 references** when the policy is used in more than one
kind of place) lists each one with a link.

### Create a policy

1. **Open Approval Policies**

   In **Settings**, click **Approval Policies**, then click **Create approval
   policy**.

   *Product example: The Approval Policies settings page with three policies and where each is used, and Create approval policy.*

2. **Name the policy**

   Enter a **Policy name** and, optionally, a **Description**, then click
   **Create policy**. Risotto opens the new policy's page.

   *Product example: The Create approval policy dialog with a policy name and description filled in, and Create policy.*

A policy name can have up to 100 characters and must be different from the other policy names in
your organization. To rename a policy or change its description, click the name on the policy's
page, edit it, and confirm.

### Add a rule

1. **Open the rule editor**

   On the policy's page, click **Add rule** next to **Approval rules**.

   *Product example: An approval policy's page with its three rules in order, and Add rule.*

2. **Name the rule**

   Enter a name for the rule, for example `Contractors`. Every rule needs a
   name, and it must be different from the other rule names in the same
   policy.

3. **Choose who the rule matches**

   Under **Requestor profile**, choose **Any profile**, or choose **Profile
   must match conditions** and enter a field and a value, for example
   `department` equals `Finance`. When a rule has two or more conditions,
   **Must match** shows **Any condition** and **Every condition**. A new rule
   starts on **Every condition**, so a person must meet all the conditions. To
   match a person who is on any one of several teams, select **Any
   condition**.

   Under **Requestor group membership**, choose **Any group**, or choose
   **Only requestors in specific IdP groups** and select the groups. With two
   or more groups, **Must be in** shows **Any group** and **Every group**.
   **Any group** (the default) matches a person in at least one of the
   groups. **Every group** matches only a person who is in all of them.

4. **Choose who approves**

   Under **Approvals**, choose **No approval needed**, or choose **Require
   approval** and add the approval steps. See [Approval
   requirements](#approval-requirements).

5. **Save the rule**

   Click **Create rule**. Risotto saves the policy and adds the rule at the
   bottom of the list.

   *Product example: The Add rule dialog: a rule for contractors that asks their manager and then the IT team, and Create rule.*

If something in the rule is incomplete, the dialog says what to fix, for example "Add an
approver, or switch to no approval needed." or "Add at least one group, or switch to any group."

For example, to let some teams get access with no approval, put a rule at the top that matches
those teams (by `department` or by IdP group) and set it to **No approval needed**. Below it, add a
last rule with **Any profile**, **Any group**, and **Require approval**. Everyone else then goes to
the approvers.

There is no limit on the number of policies or on the number of rules in a policy.

### Reorder, edit, and delete rules

The **Approval rules** table lists the rules by **Order**. Click a rule's row to show its
conditions and approvals.

- To reorder the rules, drag a rule by its handle. Risotto saves the new order when you drop it.
- To change a rule, click its actions menu, then **Edit**. Change the rule and click **Update
  rule**.
- To remove a rule, click its actions menu, then **Delete**, and confirm with **Delete rule**.

### Test a policy

On the policy's page, the **Test policy** panel shows which rule a user matches and who would
approve. Search for a user and select them. The panel shows the rule the user matches (for example
**Rule 1** and the rule's name) and its approvals. When no rule matches, it shows **No match** and
**Request denied**. When a condition cannot be checked, it shows the reasons.

*Product example: An approval policy's rules with the first one open, and the Test policy panel showing the rule a contractor matches and who would approve.*

Test after you reorder rules, where the effect of a change is hardest to see by reading. The panel
needs a connected identity provider to look up users.

Editing a policy takes effect for new requests. Requests already awaiting approval keep the chain
they were created with. See [Attaching a policy to an access rule](#attaching-a-policy-to-an-access-rule).

## Attaching a policy to an access rule

In edit mode, in an access rule's **Approval** card, choose a policy in **Approval policy**. The
card then shows the policy's rules in a read-only table, with a **View policy** link. **No policy**
keeps the rule's own approver settings. **Create a new policy** opens Approval Policies in a new
tab.

**A policy replaces the rule's inline approvers.** A rule uses a policy or its own approver
configuration, never both.

**A policy also replaces the rule's own eligibility conditions.** An access rule can carry a
profile rule and eligible IdP groups that decide who may request the app at all. Attaching a policy
hands that decision to the policy: a person one of the policy's rules matches is eligible and gets
that rule's approval requirement, and a person no rule matches is denied. When the agent looks up
apps a requestor can ask for, it leaves out apps whose policy denies them.

**Risotto resolves the policy against the user who will receive the access**, not the person who
asked. When someone requests access on a colleague's behalf, the rules are evaluated against the
colleague's profile and group membership.

**The resolved chain is captured when the request is processed.** Risotto records which policy and
which rule applied, and the approval runs against that snapshot. Editing the policy afterwards
changes the outcome for new requests and leaves requests already in flight alone.

## Attaching a policy to a tool

A policy on a tool decides who approves each call of that tool. For a tool, Risotto resolves the
policy against the ticket's requestor.

1. **Turn on approval**

   Open the tool's edit page and turn on **Requires Approval**. The **Approval
   policy** box appears.

2. **Choose a policy**

   Choose a policy from the list, then save the tool. The default, **No
   policy**, means anyone in the agent channel can approve.

When the agent calls the tool, Risotto asks the approvers of the first rule that the requestor
matches. If that rule names no approver, anyone in the agent channel can approve, as with **No
policy**. If no rule matches, the agent does not run the tool and escalates the ticket to a human.

The tool page shows a **Policy** badge and an **Approval** card with the policy's rules.

When an access rule runs the tool, the tool's approval does not apply: the access rule's own
approval does. The tool page warns about this with **Approval not enforced for access rules**.

The approver gets a **Tool Approval Request** card. Because a policy sends the card to a DM or
a channel outside the ticket thread, the card carries the context of the call, one row per
fact:

- **Ticket ID**, linked to the ticket in the dashboard
- **Request Source**, a **View original request** link to the Slack conversation the ticket
  came from
- **Tool**, the tool's name as shown in the dashboard
- **Request**, the ticket title
- **Requestor**, the requestor's name and email
- **Rationale**, the agent's reason for the call
- **Parameters**, a heading with one row for each argument of the call, for example the
  channel and the user that the call changes

Each parameter row shows the argument's name as words, for example **Requested limit**, next to
its value. Text keeps its formatting and line breaks. A list or an object shows as JSON. A value
longer than 1,000 characters is cut and ends with "…". A call with more than 20 arguments shows
the first 19 and one **Other parameters** row with the rest as JSON. In Microsoft Teams, the card
shows the same rows as a list.

The card ends with "Do you approve?" and the **Approve** and **Deny** buttons. You cannot
change the text. When the approver is a channel, Risotto also posts "Approval requested from Slack channel *#name*." in the ticket's
thread in the agent channel. Add Risotto to that channel first: if Risotto cannot post there, it
escalates the ticket.

### A different policy for one tool reference

In the runbook editor, each tool row in the **Tools** card has an **Approval** select. Choose a
policy there to use it for that reference only. It replaces the tool's own policy for calls from
that runbook step. With **No policy**, the tool's own policy applies. After you choose a policy,
**View policy** opens it.

Only Org Admins can change the select. Other editors see the attached policy. Built-in tools do
not have this select, and the automation editor does not show it.

## Attaching a policy to a runbook

A policy on a runbook decides who approves before the agent follows the runbook.

1. **Open the runbook editor**

   Open the runbook and click **Edit**.

2. **Choose the policy**

   In the side panel, under **Approval**, choose a policy. **Create a new
   policy** opens Approval Policies in a new tab. The default, **None**, reads
   "This runbook runs without approval."

   *Product example: The runbook editor's side panel with the Approval select open on the list of approval policies.*

3. **Save the runbook**

   Click **Save**.

Only Org Admins can choose the policy. Other editors see the policy's name. Once a policy is
chosen, **Edit policy** beside **Approval** opens it, and the policy's rules show below the select.

When the agent chooses a runbook that has a policy:

1. The agent sees the runbook's conditions, but not its steps.
2. Risotto asks the approvers of the first rule that the ticket's requestor matches. The request
   says "Risotto is requesting approval to follow the *runbook name* runbook."
3. After an approver approves, the agent gets the steps and continues the ticket.
4. If the approver denies, the agent does not follow the runbook. Risotto adds an internal
   comment, "Approval to follow the **runbook name** runbook was declined.", followed by the
   approver's reason when they gave one, and escalates the ticket to a human.
5. If no rule matches, Risotto escalates the ticket to a human.

A runbook policy is separate from tool approvals. After someone approves the runbook, a tool in it
that requires approval still asks for its own approval.

> **Tip:** To ask for one approval only, at the action itself, set the runbook's
> **Approval** to **None**. Keep **Requires Approval** on for the tool, and
> attach the policy to the tool or to the tool reference.

### Let only some groups use a runbook

To let only the members of one or more IdP groups use a runbook, make a policy with one rule:

- **Requestor group membership**: **Only requestors in specific IdP groups**, then choose your
  groups. For two or more groups, for example your IT group and your HR group, keep **Must be
  in** on **Any group**.
- **Approvals**: **No approval needed**.

Do not add a rule without a condition. Attach the policy to the runbook in its **Approval** property.
Members of the groups get the runbook's steps with no approval. For everyone else no rule matches,
so the agent does not get the steps and Risotto escalates the ticket to a human. You do not need
to list names in the runbook instructions. Use the policy tester to check a few people first.

## When a condition cannot be evaluated

Resolution fails closed when the identity provider cannot be reached. It stops at the first rule
it cannot evaluate rather than moving on to the next rule, and Risotto escalates the ticket to a
human instead of granting access.

This is deliberate. Treating an unreachable provider as "does not match" would advance to the next
rule and, eventually, to a catch-all rule, so an identity provider outage would quietly drop the
contractor approval gate and grant access with no approval at all.

The same applies to a user with no profile in the provider, and to a rule with profile conditions
when your organization has no identity provider configured. In each case Risotto reports what it
could not resolve.

## Deleting a policy

1. **Open the policy's menu**

   In **Settings → Approval Policies**, click the actions menu on the policy's
   row, then **Delete**.

Deleting a policy is refused while anything still uses it:

- A live access rule.
- A runbook, when the policy is on the runbook or on one of its tool references.
- A tool.
- An automation, when the policy is on one of its tool references.

The **Can't delete approval policy** dialog says "This policy is still in use. Remove it from the
resources below before deleting." Click the button under it to list each one with a link. Choose
another policy, or no policy, on each of them, then delete.

*Product example: The Can't delete approval policy dialog, with the button that lists the resources still using the policy.*

Source: https://www.tryrisotto.com/docs/dashboard/settings/approval-policies
