Back to all work

Singlecomm · 2015 · Senior Product Designer

Cutting script deployment time from 8 weeks to 3 days.

I designed a no-code scripting platform that let Singlecomm's enterprise clients build and deploy call-center scripts without engineering help. Beachbody alone saved over $100K a year.

Singlecomm Guided Interactions workflow masthead

Overview

In 2015, I led product design at Singlecomm, a cloud contact-center platform. Their enterprise clients had a bottleneck: script creation was slow, costly, and dependent on engineering. Scriptwriters couldn't own their own workflow.

I led the end-to-end design, from discovery and strategy through prototyping, testing, and delivery. I worked with the PM to define scope and partnered with engineers to de-risk key interactions, including drag-and-drop logic and live preview. I built a coded prototype in HTML/CSS/JS so the team could validate flows with users and show stakeholders a concrete MVP.

Role
Senior Product Designer
Company
Singlecomm
Year
2015
Client featured
Beachbody
Research
12 scriptwriters, 2 developers, 2 business leaders

The challenge

A costly and inefficient process

Script creation was slow, costly, and dependent on engineering. Even minor updates took weeks and needed developer time. That delay held back marketing, limited personalization, and cost clients revenue.

My challenge: give non-technical scriptwriters a way to build and iterate complex call flows on their own, at scale.

8 weeks
Average time from script concept to deployment
2–3 weeks
Typical turnaround for minor adjustments or revisions
75+
Active scripts managed simultaneously at peak
12+
Call centers coordinated for sales and support
Making modifications to scripts would take an enormous amount of time; in our market, an enormous amount of time is not acceptable.
Lee Swanson, SVP of Telemarketing, Beachbody

Discovery

Understanding the pain behind the workflows

To diagnose the problem, I ran mixed-methods research (interviews, task analysis, journey mapping) with 12 scriptwriters, 2 developers, and 2 business leaders across three enterprise clients.

Interviews

I interviewed scriptwriters, developers, and business leaders to map the end-to-end workflow and locate the real pain points.

  • Scriptwriters were frustrated by their reliance on IT, which slowed down development.
  • Most found their tools too technical, relying on Excel, code, or rigid templates.
  • Teams needed multiple separate tools to plan and map conversation flows.
  • Heavy IT dependency for simple script updates frustrated IT and scriptwriters alike.
  • Slow deployments delayed necessary script changes during product launches.

Task analysis: shadowing scriptwriters at work

I shadowed four scriptwriters as they built, modified, and tested scripts in real campaigns. Tasks I observed:

  • Adding conditional logic for upsell opportunities
  • Modifying scripts mid-campaign based on performance data
  • Creating A/B test variations
  • Submitting IT requests for technical changes

Key issues:

  • Tool fragmentation made the work error-prone. Scriptwriters carried heavy mental load translating flows between systems.
  • No visual feedback or quick testing, so errors compounded.
  • Slow change cycles from heavy IT dependency.
Example call-script flowchart showing screen-by-screen conditional branching across welcome, qualification, product offers, payment, shipping, and close

Mapping the end-to-end journey

I synthesized findings into a swim-lane workflow covering concept to deployment, with the four pain points anchored to the stages where they showed up. It helped the team align on where time was being lost and where design could move the needle.

Swim-lane workflow showing scriptwriter, internal team, and system actions across six phases, with wait states and pain points called out

Synthesized insights: four core problems

Fragmented tools

Scriptwriters juggled four or more tools, context-switching constantly, making errors, and burning time.

IT bottlenecks

Simple logic changes averaged 12 days and required engineering, delaying campaign launches.

Delayed testing

Without validation tools, errors were only found post-launch. Live customer calls became the QA.

Inefficiencies cost revenue

The breakdowns cost real money: lost revenue, lower conversion rates, missed market opportunities.

Design strategy

Translating research into a system scriptwriters could actually use

I turned the research into four principles, each targeting a specific failure mode in the old workflow.

One platform

Centralize scripting from planning to deployment. Eliminate tool fragmentation.

Visual authoring

Give scriptwriters a drag-and-drop canvas modeled on flowcharts they already understood.

Logic without code

Make conditional branching, SKUs, and dynamic inputs accessible without engineering.

Preview as you build

Real-time validation and visual feedback, so QA doesn't gate iteration.

It took 2–3 weeks for a change to take place, that greatly impacted our ability to validate the scripts.
Enterprise scriptwriter, discovery interview

Ideation

Turning pain points into possibilities

I ran a structured ideation session with scriptwriters, PMs, and engineers. Three How Might We questions framed the discussion, each grounded in research.

  • How might we help scriptwriters write scripts with less IT support?
  • How might we help scriptwriters identify underperforming scripts?
  • How might we help scriptwriters fix script issues independently?

Through sketching, dot-voting, and clustering, we landed on three high-impact design directions:

  • Visual editing: building call flows through a drag-and-drop interface.
  • Conditional logic without code: branching accessible to non-technical users.
  • Real-time preview: instant feedback and validation while building.

I turned these into wireframes and flows, partnering with engineering and PM on scope and feasibility before prototyping.

How Might We ideation workshop output
Workshop sketches from the ideation session

Concept testing

From concept to confidence

I built an HTML/CSS/JavaScript prototype and tested it with five enterprise scriptwriters. All five built multi-path scripts. The session surfaced four things to fix.

Script builder prototype demonstration

Users grasped the flowchart metaphor instantly

"This feels like something I already use, like Lucidchart or Visio."

"It's easy to move things around and see what I'm building."

Solution. I leaned into the familiarity, refining node styles and snap-to-grid behaviors to match the tools they already trusted.

Confusion around conditional logic fields

"What happens if I need different upsells for different products?"

"I'm not sure what this logic node will do."

Solution. I added tooltips and onboarding prompts, plus pre-built logic templates for common use cases.

Strong desire for live preview

"I want to see how this looks for the agent right away."

"Without preview, I'm guessing if it's right or not."

Solution. I prioritized live preview in the next sprint. The panel updates in real time as users build.

Users wanted to reuse blocks of logic

"I use the same upsell flow in five different campaigns. Can I copy it?"

"It would be great to save my best-performing scripts."

Solution. I scoped a reusable "block library": save best-performing scripts, drop them into new flows.

Testing validated visual clarity, non-technical usability, and real-time feedback as the right anchors. With the core scripting concept confirmed, I moved on to the supporting systems: drag-and-drop form builder, conditional branching builder, and SKU builder.

Outcome

The outcome

The redesign cut script deployment time from 6–8 weeks to 3 days. Beachbody alone saved over $100,000 a year in IT costs and launched faster across 12+ call centers.

The drag-and-drop tool put logic and personalization directly in business users' hands. IT requests dropped. Iteration accelerated. The architecture it produced (reusable components, modular flows) seeded Singlecomm's later platform work, including white-labeled scripting tools for multiple clients.

$100K+ a year
Saved for Beachbody alone by offloading scripting to business users.
8 weeks → 3 days
Script deployment time, after the new platform shipped.
Faster iteration
From quicker launches and shorter optimization cycles.
Visual editor canvas with drag-and-drop script nodes

Visual editor

Design, edit, and launch call flows in minutes with a drag-and-drop canvas. No code, no bottlenecks.

Form builder for names, addresses, and payment info

Form builder

Create custom data entry forms for names, addresses, payment info, and more.

SKU builder interface for products and bundles

SKU builder

Add and manage product SKUs inside the script, tailoring offers, upsells, and bundles in real time.

Conditional branching interface with if/then logic

Conditional branching

Build dynamic, responsive call flows with simple if/then logic, guiding agents to the right path every time.

Speed to market has been the biggest benefit we've derived from the SingleComm tool.
Lee Swanson, SVP of Telemarketing, Beachbody
Like what you see? Let's talk.

hello@rod.me