Summary
Problem: About 6k customers used SSO, but only ~1.2k used provisioning.
Admins still finished every new user’s setup by hand.
My role: Joined a third of the way in and became lead designer for the
template system: rule builder, variables, number pools, logs.
Key decision: Traded inline flexibility for a card summary plus modal
rule builder, so admins could scan and trust their rules.
Outcome: Cut initial provisioning setup time by 56%. Shipped to: Alpha /
25 customers.
1. Problem & Hypothesis
There was strong customer demand for automated provisioning, but adoption of the
existing integration was low. The cost of onboarding and off-boarding stayed high
because IdP sync only carried basic identity—admins still had no scalable way to:
- Assign licenses
- Apply default settings
- Automate workgroup or permission assignment
- Free up licenses when off-boarding
~20% provisioning uptake
About 6k customers used SSO, but only
~1.2k used provisioning integration—a clear gap between identity
for authentication and identity for automating employee setup.
The blocker wasn’t connecting the IdP. It was everything admins still had to do by
hand after each user synced.
90% Microsoft Entra ID
Most integrations used Microsoft Azure AD / Entra ID, so it was the critical
ecosystem to design around.
Goal
Reduce repetitive post-deployment setup for enterprise admins—encode policy once
in templates, then apply it when IdP lifecycle events arrive.
Existing flow
- Employee is created in the company’s Microsoft Entra ID.
- Basic user information automatically syncs to 8x8.
-
Admin still completes the employee’s 8x8 setup (licenses, voice settings, workgroup
or permission assignment, and related configuration).
-
Depending on services, IT admins also configure the user in Contact Center
Configuration Manager and/or Voice for Teams admin.
2. Role & Collaboration
I joined the User Provisioning initiative roughly one-third of the way through the
project, when the Staff Product Designer originally assigned to the work transitioned
to another initiative. I then became the lead product designer, taking
ownership of the core template experience and expanding the system as new provisioning
requirements emerged.
When I took over, the template model relied on static configuration. I expanded it to
attribute-driven rules, so one template could serve many user types.
Owned
- Template creation / deletion
- Rule builder
- Number pools
- Identity & security settings
- Template logs / activity
- Variables
PM
Requirements · prioritization · business rules
API Engineer
Backend model · capabilities · constraints
Frontend Engineer
Interaction patterns · custom components
3. Proposed Solution
I worked closely with the PM and API engineer to map the provisioning logic before
designing screens—answering four questions the template system had to make explicit:
- Who gets the template?
- What configuration applies?
- When does it apply?
- What happens if something fails?
From there, I used iterative workflow exploration and prototyping for template creation,
deletion, logs, number pools, and SCIM setup. The original model leaned on static
configuration; I expanded it to support attribute-driven rules so
admins could determine both who receives a template and how individual settings resolve.
4. Validation
Two rounds of usability testing with 5 IT admins, who created and tested
a provisioning template end to end. Validation → iteration broke into three buckets:
Validated
All participants completed the template-creation flow.
Refine
Error diagnosis and progress / navigation needed clearer feedback.
Open question
What happens when multiple templates match the same user? (precedence)
Resolved: Templates got an explicit priority order. When several
match, the highest-priority template applies, and the template list shows priority so
admins can see and reorder it.
Refinement: error diagnosis
Template logs had to connect Activity, the template list, and detailed template logs so
admins could understand failures the Template Engine hit while provisioning users.
5. Challenges Faced
The biggest challenge wasn’t fitting more configuration into the template builder—it
was deciding how much flexibility admins actually needed without making the system
harder to understand. Areas that required significant iteration included rule creation,
workflow orientation, dynamic variables, and template precedence.
Design decision: I deliberately traded theoretical flexibility for
practical usability.
1. Rule builder: flexibility vs. cognitive load
Challenge: The first exploration was an
inline row-based builder—more flexible, more choices, but higher
cognitive load from an endless scroll of nested parameters.
What I learned: Supporting every possible configuration inline
made rules harder to scan and easier to misconfigure—without enough value for the
initial use cases.
Decision: I moved to a
card-based summary + modal builder: fewer decisions on the page,
scannable rule summaries, and contextual focus when editing a single rule.
2. Progress indicator: making the workflow legible
Challenge: In the first round of usability testing, users could
complete the template flow, but some were unsure which step they were in and what
remained.
What I learned: Completing the flow wasn’t enough—admins still
needed clearer signal for where they were and what was left in the multi-step
creation process.
Decision: I revisited the process indicator to make the current
step, completed steps, and remaining steps easier to understand, strengthening
orientation within the creation flow.
3. Variables: flexibility without template duplication
Challenge: Template attributes aren’t always static. An admin may
need a value to change depending on the employee’s attributes—such as site or role.
Without variables, admins would duplicate templates for each scenario.
What I learned: Exposing raw expression power isn’t enough—the
mechanism has to stay approachable for admins who shouldn’t need to understand the
underlying logic. Example:
Extension number = {{User.Site == "NYC-Headquarters" ? "1001" : "2001"}}
Decision: We deferred variables past Alpha to keep the first release
focused. For post-MVP iterations, I let admins use variables inside attribute fields
while keeping configuration understandable—flexibility without forcing template
duplication.
4. Precedence
Challenge: Usability testing surfaced an open question: what happens
when more than one template matches the same user?
Decision: Admins set an explicit priority order, and the
highest-priority match wins. The final template list shows each template’s priority
so admins can see and adjust it at a glance.
6. User & Business Impact
Final experience
The shipped direction consolidated templates into a scannable list with health status,
creation vs. deletion scope, licenses, and priority—plus a Template log for diagnosis.
Outcome
The template system shipped to Alpha with ~25 enterprise customer admins. In Alpha
measurement of the new-user creation flow, configuring a new user with a template took
~56% less time than the manual flow.
The project was paused before general availability for company reasons, so adoption at
scale wasn’t measured. Setup time was the leading indicator: the original adoption gap
came from admins still doing manual post-sync setup, and templates removed most of that
work.