Summary
Outcome: GA in December 2025 after a 30-customer beta. In the first
usability round, 100% of admins configured a request and 80% tested it. Response mapping
(60%) surfaced as the main drop-off, which drove a redesign.
Principle that shaped the work: the technical architecture didn’t need
to become the user’s information architecture.
1. Problem: a simple lookup that cost customers a services contract
An API Data Dip fetches data from an external system during a live
interaction. It answers questions like “Who is this caller?” or “Where’s my order?”
without the agent leaving the workflow.
8x8 workflows couldn’t do this natively. Customers who needed a basic CRM or order lookup
had to buy add-on products or pay for professional services.
Admin pain
No way to bring CRM, database, or API data into Collect → Check → Decide steps.
Business pressure
RFPs increasingly required integrable workflows, and competing CCaaS platforms
already offered this.
Why it matters
With customer data fetched before the agent answers, calls can route to the right
queue automatically (for example, VIP or past-due accounts) and agents skip basic
identity questions.
Opportunity: let the contact-center admin configure the request in the
workflow, then continue the interaction with that context.
2. My role
As Lead Product Designer, I owned the workflow model, information architecture,
interaction design, prototyping, and usability iteration.
PM
Requirements, prioritization, business rules
Engineering
API capabilities, legacy constraints, feasibility
User Research
Study planning, beta program
3. Approach: break the API down before designing screens
The core challenge was giving a contact-center admin, not a developer, access to
developer-level power. Before opening Figma, I broke an API call into what it actually
requires: making a request (method, URL, auth, headers, body) and handling the response
(test, inspect, map to variables, handle errors).
That breakdown became the admin’s three-step flow:
- Configure the request
- Test it with sample variable values
- Map the response into workflow variables
Early prototypes explored each step on its own, to answer three questions: how do I build
the request, how do I know it works, and how do I use what comes back?
4. Key decisions
1. Extend the existing variables model rather than create a new one
Context: API response data had to feed the Collect → Check → Decide
steps admins already used.
Considered: a separate “API data” panel just for response fields.
Chose: extend the existing Variables experience so mapped fields
appear alongside the variables admins already know.
Why: a second, parallel model would mean admins learning two systems
for one job.
2. Flatten the information architecture to match the task
Context: the first IA mirrored the technical structure, which buried
the admin’s actual task under extra layers of hierarchy.
Chose: remove a level so the IA follows Configure → Test → Map
directly.
Why: admins think in steps of the job, not in parts of an HTTP
request. The technical architecture didn’t need to become the user’s IA.
3. Guide beginners without hiding power
Context: the feature is inherently technical (auth, headers, JSON
paths), but testing showed most admins were beginner-to-intermediate.
Chose: progressive disclosure plus inline guidance (tooltips,
explained next steps) rather than exposing every API option up front.
Trade-off: advanced users take one extra click to reach full
options, a cost we accepted to make the default path completable.
4. Design fast, ship to legacy
Context: legacy code fixed the modal height, and the Oxygen
design-system components couldn’t be used.
Chose: prioritize task clarity inside the existing frame, fitting
authentication (including OAuth2) and response mapping within a fixed height.
How I worked within it: I designed in Oxygen components to iterate
quickly, then mapped key screens to their legacy equivalents so engineering could see
exactly how it would render. Engineering matched the legacy implementation closely,
so little of the design intent was lost.
5. Testing: finding the drop-off, then fixing it
Round 1: 5 participants, real 8x8 admins, moderated remote sessions.
| Step |
Round 1 completion |
| Configure request |
5 / 5 |
| Test request |
4 / 5 |
| Map response |
3 / 5 |
What we learned: configuring was intuitive, but mapping a JSON response
to variables lost two of five admins. Participants were beginner-to-intermediate. They
wanted reassurance at each step, and tooltips helped them work out what to do next.
What I changed in mapping
-
Made path selection easier to find: highlight a field in the response preview to open a
fly-out menu for mapping it
- Added a preview of the value before it’s assigned
-
Offered a table view alongside code view, for admins who don’t read JSON
The redesigned mapping went into the beta.
6. Outcome
Admins can now configure, test, and map an external API call inside the 8x8 workflow,
with no add-on product or services engagement.
Signals so far
- 27 workflows built with Data Dips across 30 customers
- 14 professional-services engagements avoided
Contact-center setups vary too widely to claim a single reduction in handle time or
misroutes. Instead, this case relies on what we measured directly: task completion in
testing and beta adoption.
7. Reflection
-
What worked: breaking down the API before designing screens kept the
flow tied to the admin’s task, not the protocol.
-
Next: Handle timeouts and API failures mid-call. Extend Data Dips to
other channels.