API Data Dips

Letting contact-center admins pull external customer data into live workflows — no extra products or professional services required.

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.

Problem diagram: external customer data sits outside the contact-center workflow
Before: external data sits outside the workflow admins control.

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:

  1. Configure the request
  2. Test it with sample variable values
  3. Map the response into workflow variables
Decomposition of API Data Dip into making a request and dealing with the response
Decomposing the API workflow before designing screens.

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?

Configure — early exploration of constructing the request.
Test — early exploration of verifying the request works.
Map — early exploration of turning the response into workflow variables.

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.

Existing Variables modal in the contact-center workflow
Existing Variables modal.
Updated variables model for API data
Updated variables for API data.
Team collaboration artifact for updated variables
Aligning the variables model with the team.

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.

Before: deeper information architecture hierarchy
Before: deeper hierarchy.
Before: alternate view of the deeper hierarchy
Before: task buried under structure.
After: simplified information architecture aligned to the admin task
After: IA flattened to match Configure → Test → Map.

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.

Legacy-constrained OAuth2 authentication configuration in the modal
Legacy constraint — authentication (OAuth2) in the modal shell.
Legacy-constrained response mapping UI
Legacy constraint — response mapping within fixed height.

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
Response mapping via code — step 1
Mapping via code — step 1.
Response mapping via code — step 2
Mapping via code — step 2.
Response mapping using a table
Mapping using a table.

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.

Final experience — configure, test, and map end to end.

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.