All case studies

Case study 02  Quick peek  2 min read

Enterprise Tool Governance

Turning a fragmented enterprise-software administration process into a governed system—and exploring how AI could safely take on repetitive decisions within limits set by humans.

Real operational problem  Agentic AI concept

A request, an admin decision and a governance signal: a Full seat request for dashboard reviews, the agent suggesting a Collab seat with its reasons and an Approve Collab button, the Suggest, Ask, Act autonomy levels, and seat utilization with reclaim candidates
Role
Product / UX Design  Admin domain expert
Users
Employees, managers and enterprise-tool administrators
Domain
Enterprise software governance
Scope
Requests, allocation, utilization, cost visibility and AI-assisted governance
Status
Concept / working prototype based on a real operating problem

The real problem

Ten admins. One enterprise account. No shared operating layer.

A global enterprise tool, Figma, was administered by a small, distributed group of admins whose primary jobs were elsewhere. Requests arrived through several channels, and every decision needed context someone had to go and find.

The work was spread across
Chat messages
Email
Request forms
The vendor’s admin console
Admin coordination
User activity
AI-credit usage
Inactive-seat reviews
Plug-in and security requests
Organizational changes

Questions admins answered, one request at a time

  • Does this person actually need a paid seat?
  • Which seat type fits the work?
  • Is there an available seat to reuse?
  • Is an assigned seat inactive?
  • Should additional AI credits be approved?
  • Which admin should act?
  • Has the requester already asked?
  • What happens if usage changes later?

The enterprise admin console was only one part of the operating model. The surrounding request, approval, communication and governance work remained fragmented.

My role

I lived the problem before I designed for it

I was one of the admins managing the problem in addition to my primary design responsibilities. That gave me participant-observation access to the request patterns, admin coordination, recurring decisions and operational friction. I first explored the workflow as a conventional governance tool, then evolved it into an Agentic AI concept with explicit autonomy boundaries.

What I saw as an admin

  • How requests really arrived, and what they left out
  • Coordination between admins in different time zones
  • The same decisions about seats, credits and plug-ins, again and again
  • Workarounds the console alone couldn’t remove

What I designed

  • The operating model: lifecycle, roles and rules
  • The request and admin experience
  • The agent’s interaction model: Suggest, Ask, Act
  • Guardrails, undo and audit
  • A working prototype

Key insight

The problem was not assigning seats. It was governing decisions over time.

A better request form would not solve what the admins kept coming back to.

What a form alone doesn’t handle
Repeated requests
Inactive users
Budget pressure
Exceptions
Temporary needs
AI-credit usage
Reallocations
Offboarding
Unclear ownership

SoThe system had to manage the full lifecycle.

Pivotal decision

I redesigned the operating model before designing the AI.

If rules, roles and escape routes are unclear, an AI agent only automates inconsistency. The governance structure had to come first.

Governance model

  1. Request

    Someone asks for access, a different seat type or more AI credits.

  2. Evaluate

    Need, role, budget, availability and policy.

  3. Assign

    Provision the access that fits the work, not the most expensive one.

  4. Monitor

    Watch activity, credit use and limits over time.

  5. Reclaim

    Recover underused access, with the owner told first.

  6. Reuse

    Allocate existing capacity before buying more. Reuse feeds the next request.

The real product was the operating model around the license.

Agentic AI concept

Suggest → Ask → Act

Once the workflow was structured, I explored where AI could take on repetitive admin decisions. The agent never gets unlimited autonomy: each kind of request has a level, and admins set it.

  1. Lowest autonomy

    Suggest

    The system recommends an action but does not execute it.

    Typical triggers

    • An inactive seat
    • An unusual request
    • An ambiguous project need
    • Sparse context
    • A high-cost or sensitive exception
  2. Pauses for a person

    Ask

    The system stops and asks an admin, or the requester, for a decision.

    Typical triggers

    • Missing information
    • Conflicting signals
    • Exceptions
    • Policy uncertainty
  3. Highest autonomy, still bounded

    Act

    The system executes reversible, low-risk actions within rules admins define.

    Concept examples

    • A Dev or Collab seat that fits the role, while the team has seats
    • An AI-credit top-up within the monthly allowance
    • Every action undoable for 24 hours

Autonomy principleAutonomy follows reversibility.

The harder an action is to reverse, or the more financial or security impact it carries, the less the agent may do on its own. That one rule decides which requests land in Suggest, Ask or Act.

Key design moments

Four moments that carry the story

Screens are recreated with sample data, white-label and without any employer branding. Names, numbers and policies are examples.

A

A self-service request entry

Problem
Requests arrived through chats, email and forms, each with different, often missing, information.
Decision
One entry point with a request type, plain-language choices for what the person will do, and the status of every request in one place.
Why
Governance starts with consistent, structured information. A request that already says what the work is can be decided, or automated, safely.
Recreated screen · sample data. Employee request screen: a request type switch for seat, AI credits or plug-in, four plain-language choices for what the person will do in Figma, with the Dev seat marked as fitting their role, fields for project, duration and purpose, the manager added automatically, and a link to talk to an admin instead
B

The admin decision queue

Problem
Admins had no shared, prioritized view: each one worked from their own messages.
Decision
A queue showing request context, status, risk and usage signals, and the recommended next step, with what needs a person first.
Why
It turns coordination between admins into a visible operating system, and any admin can pick up any request.
Recreated screen · sample data. Admin decision queue: five requests with the requester, the request, a signal such as team at its limit, reviews only, little context, inactive or fits role, and the next step shown as Ask, Suggest or Act. The selected request opens a side panel: a Full seat request with no design edits and 46 comments in 90 days, one Full seat left in the team, a suggestion to approve a Collab seat with the reasons, and buttons to approve Collab, approve Full or ask the requester
C

Suggest → Ask → Act, set by policy

Problem
Not every request should get the same level of automation.
Decision
Make autonomy explicit and policy-controlled: admins decide which kinds of request the agent may act on, only suggest, or must ask about.
Why
Admins can always tell whether the system is recommending, requesting approval or acting.
Recreated screen · sample data · policies are examples. Agent policy screen set by admins: six kinds of request mapped to what the agent may do. It may Act on a Dev or Collab seat that fits the role and on an AI-credit top-up within the monthly allowance, both with a 24-hour undo. It may only Suggest for a Full seat, a seat inactive 60 days or more, or a plug-in request. It must Ask when context is missing, signals conflict or the team is at its limit. Below, safety controls: 24-hour undo on, a circuit breaker that drops the agent back to Suggest after three undos, and a Pause agent button
D

Undo, audit and reasoning

Problem
Enterprise admins need accountability and a way to recover from a wrong call.
Decision
Make every action reversible and inspectable: a 24-hour undo, a reason on every entry, and admin overrides logged next to the agent’s actions.
Why
Trust comes from control, not from pretending the AI is always correct.
Recreated screen · sample data. Audit log: a confirmation that the agent approved a Dev seat with undo available for 23 hours, then a timeline of five actions with time, mode and reason: an approved Dev seat with its rule and an Undo button, a suggestion of Collab instead of Full waiting for an admin, an admin overriding the agent with the reason given, the agent asking a requester two questions, and an AI-credit top-up within the allowance
Working prototype

Test the governance agent

This working prototype combines the original governance workflow with a simulated Agentic AI layer. The agent behavior is rules-based for demonstration; the goal is to test interaction patterns, autonomy boundaries and admin trust—not claim a production AI implementation.

Test the governance agent (opens in a new tab) Opens in a new tab  best on a desktop screen

Outcome

What the evidence shows, and what is modeled

  • Observed evidence

    Admin coordination was fragmented across channels. The same governance topics came back meeting after meeting, and a request audit surfaced 285 open items across the admin group.

  • Operational outcome

    The concept centralizes request, allocation and governance work in one operating model, with clear rules, roles and escape routes.

  • Modeled outcome

    About 80 → 15 admin hours a month in the concept’s model.

    Modeled scenario — not production data

  • Project status

    A concept and working prototype based on a real operating problem. The autonomous governance system was not deployed.

View the deep dive