Back to Blog Home

How to Build an AI Onboarding Approval Workflow

Illustration of a request card stopping at a checkpoint gate that a human stamp releases

Classify an onboarding action into one of three tiers by what it changes, and make the assistant unable to complete the consequential ones. A person approves, the workflow executes once, and the employee hears "go ahead" only after the target system confirms the change. Approve role bundles once, so reviewers see real exceptions and not a stream of defaults. A company brain can explain a travel policy or show a new hire where to request software. It should not approve an exception, grant access, confirm regulated work or mark mandatory training complete on its own.

What a citation does and does not prove

A company brain combines retrieval, generation, workflow state and integrations. Retrieval-augmented generation grounds an answer in external knowledge. Grounding improves relevance, but a cited policy is still evidence and not permission. A policy may say an employee can request finance software. It does not prove that this employee has a business need, that the license is available, or that the manager accepted the cost.

New hires are especially likely to read a confident answer as a decision. They do not yet know which steps are informational, which owners control an exception or which systems hold the final state. "You can now use the payroll export" is dangerous if the assistant only created an unapproved ticket. Treat authority as a separate property from answer quality: a correct answer can still be unauthorized, and a well-routed approval can become invalid when the employee's role, start date, manager, policy version or requested resource changes.

Three tiers, set by consequence

Do not send every onboarding interaction to a manager. That recreates the manual queue the company brain was meant to reduce. Classify actions by consequence instead:

  1. Guidance covers approved-source explanations, links and routine next steps. These interactions do not change state and need no approval.
  2. A reversible workflow can create a draft request, schedule a reminder or assign optional reading. Automation may proceed when the employee can undo the action and it creates no meaningful access, financial, legal or safety impact.
  3. A consequential decision changes access, money, employment records, mandatory completion, regulated duties, policy exceptions or another person's obligations. An accountable human must approve it before execution.

Map the consequences before you build, as the NIST AI Risk Management Framework suggests, and keep the result in a short decision register. For each action, record the system changed, the possible harm, the approver role, the evidence required, the approval lifetime, the execution method and the verification check. Do not use a model confidence score as the risk tier, because confidence describes the model's output and not the business effect of an action. People Operations should own employment and policy decisions, IT should own identity and application access, and a hiring manager should own team-specific cost and duty decisions. Some requests need two owners.

Approve the role bundle once

We recommend moving approval up a level. Most new-hire access is the default for the role, and a per-person approval for each default entitlement teaches reviewers to click through. Have the application owner approve each role bundle once, for example the default access for a finance analyst, with an owner, a review date and an expiry. The workflow can then grant the bundle from the start event without a per-hire request, and only access outside the bundle becomes a tier-three request. Reviewers then see few requests, and each is a real decision.

Build the request record before the interface

The request needs a stable record that a reviewer can read without replaying a chat transcript. Store these fields:

  • request ID and creation time
  • employee identity, role, location, manager and start date
  • requested action and target system
  • risk tier and the rule that assigned it
  • governing source URL, source version and retrieved passage
  • current access context
  • business justification supplied by the employee
  • approver role and resolved approver identity
  • decision, reason, decision time and expiry time
  • execution state and external system reference
  • verification result

Retrieval must respect the employee's current permissions before the request is assembled. Microsoft's document-level access control guidance describes filtering search results with identity or group criteria. Apply that filter before generation and again when rendering the approval packet, so an approver does not receive hidden documents merely because the employee asked a related question. Keep the assistant's explanation apart from the machine-readable fields. Free text can help the reviewer, but the target account, access role, amount and policy version should come from authoritative systems or a constrained selection list.

A minimal state model:

RECEIVED
 -> NEEDS_INFORMATION
 -> PENDING_APPROVAL
 -> APPROVED
 -> EXECUTING
 -> VERIFIED

PENDING_APPROVAL -> REJECTED
PENDING_APPROVAL -> EXPIRED
APPROVED -> STALE
EXECUTING -> FAILED

Only VERIFIED means the employee may proceed. APPROVED means a person accepted the request under a specific context, and it does not prove that the downstream change succeeded.

Route the decision to an accountable person

Resolve the approver from current organizational data, not from a name the employee types into chat. Application access goes to the application owner or a delegated access approver, and a policy exception goes to the policy owner. If the owner cannot be resolved, fail closed and send the request to a maintained operations queue. The GitLab onboarding handbook uses explicit tasks, access requests, onboarding participants and completion actions, and a company brain should preserve that accountability instead of collapsing every role into one automated assistant.

Give the approver a compact packet: what will change, who requested it, why it is needed, which source governs it, what the employee can currently access, when the decision expires, and what verification will run after execution. The reviewer should be able to approve, reject, request information or reassign to the correct owner. Require a reason for exceptions and rejections. It gives the employee and the knowledge owner useful feedback, but it should not train a model automatically without a separate review.

Set a service target for each request class. A blocked day-one application request may need a response within hours, and a nonessential equipment exception may wait longer. Escalate overdue requests to a backup owner, and never convert silence into approval.

Expire approval when context changes

An approval is valid only for the context the reviewer saw. Build a context fingerprint from the normalized fields that fed the decision (role, department, manager, location, start date, requested application, permission level, amount, effective date, policy version, approver authority and employee status) and rebuild it at execution time. If it differs from the approved value, move the request to STALE and explain what changed. Do not ask the model whether the change is material, because explicit rules should make that call.

Approval should also expire after a defined period. A software-access approval granted before a delayed start may not be appropriate months later, so set the lifetime by action type and not with one global duration.

Execute once, then verify

After approval, call the downstream system with an idempotency key based on the request ID, so a timeout and retry cannot create a duplicate grant or record. Keep execution and verification apart:

  1. Mark the request EXECUTING.
  2. Submit the constrained action to the target system.
  3. Save the external ticket or transaction reference.
  4. Read the target system's current state.
  5. Compare that state with the approved request.
  6. Mark the request VERIFIED only on an exact allowed match.
  7. Tell the employee what changed, who approved it and where to confirm it.

If the target system only acknowledges receipt, leave the request in progress. Never translate "ticket created" into "access granted."

Kipwise positions employee onboarding around assigned reading and searchable company knowledge. Use that knowledge layer to explain the process and show the governing source. Keep the actual authority in the owner and system responsible for the decision.

Example: a finance application request

A new finance analyst asks the company brain for payroll export access. The assistant retrieves the approved access policy and explains the normal request path. Because the requested permission exposes sensitive records, the action is classified as consequential.

The workflow builds a request from the employee ID in the authenticated session, the role and manager from the workforce system, the application role from a fixed catalog and the policy version from the retrieved source, and routes the packet to the finance system owner and the analyst's manager. The manager confirms the duty requirement, and the application owner approves the least-privilege role for 30 days. Before execution, the workflow checks that the analyst still has the same role, manager and active employment state. It then submits the grant, reads the application's membership record and confirms the expected role and expiry date.

The assistant can now say: "Your Payroll Export Viewer access was approved by the finance application owner and verified in the application. It expires in 30 days. Review the handling policy before exporting data." If execution failed, it should show the failure state and the support owner instead. The wording has to reflect observed state, not the optimistic path.

When something goes wrong

  • No approver can be found: send the request to an owned exception queue and alert the workflow owner to repair the ownership map. Do not nominate the new hire's nearest visible manager as a guess.
  • The approver is unavailable: use a documented delegate and record the delegation in the request. An administrator should not approve every category merely because they can operate the tool.
  • The governing source is missing or conflicting: stop the decision and link the employee to a human owner who can resolve the policy. A packet without governing evidence asks the reviewer to invent policy in the moment.
  • Context changes after approval: mark the request stale and return it for review with a field-level difference.
  • A downstream timeout: query the target system before retrying, and use the request ID to detect whether the change already happened.
  • A verification mismatch: if the system granted broader access than approved, trigger removal or incident handling and tell the employee not to use the permission.
  • Chat delivery fails: keep request state in a durable workflow store, so the employee can reopen the request without creating a second one.

Test the gate and watch the approval rate

Test each risk tier with representative onboarding requests, and write the adversarial cases first: an employee who names an unauthorized approver, a role that changes between approval and execution, a target system that times out after it has already applied the change, and a source document the approver is not allowed to see. Each should end in a refusal, a stale request, a single grant or a hidden document, and never in a success message the system cannot back up. Guidance must never change an external system, and a chat response alone must never execute a consequential action.

Run a reconciliation job that compares approved requests with downstream state. Look for verified requests whose target state disappeared, active grants whose requests expired, and executed changes with no matching approval, and review these exceptions with the system owner.

Track the measures that expose friction: time to first review, expiry rate, stale-context rate, rejection reasons, execution failures, verification mismatches and requests with no owner. A high rejection rate may mean the assistant invites unsupported requests, and a high expiry rate may mean routing is too slow. An approval rate near 100 percent means either those requests belong in a pre-approved role bundle or reviewers are not reading them. Use the measures to repair rules and ownership, not to pressure reviewers into approving faster.

Put one action behind the gate

Choose one onboarding action that currently mixes guidance and authority, such as application access, a policy exception or mandatory completion. Write its risk rule, name its accountable owner, define the approval lifetime and specify the downstream verification check. Then run the full request, approve, expire, execute and verify loop for that action. Expand only when no consequential change can occur without a valid approval.

Topics

Related posts

Your team’s knowledge, answered in Slack

Add the Kipwise Agent. It answers from your pages with the source, and asks before it changes anything. 7-day trial, no card needed.