Singlecomm · Senior Product Designer
Cutting script deployment time from 8 weeks to 3 days.
I designed a visual script builder that let scriptwriters build and launch branching call flows without engineering help. Beachbody alone saved over $100K a year in IT costs.
- Role
- Senior Product Designer
- Company
- Singlecomm
- Client featured
- Beachbody
- Research
- 12 scriptwriters, 2 developers, 2 business leaders
Overview
I led product design at Singlecomm, a cloud contact-center platform. Their enterprise clients had a bottleneck: scriptwriters couldn't own their own workflow. Every script ran through engineering.
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.
01 / 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.
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
02 / 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.
Task analysis: built by hand, tested live
I shadowed four scriptwriters as they added upsell logic, adjusted scripts mid-campaign against performance data, built A/B variations, and filed IT tickets for anything technical. Watching the work surfaced what interviews couldn't: they rebuilt every flow in each system, screen by screen, with no way to preview or test along the way.
Interviews: sixteen conversations, one story
Scripts lived in Excel, code, and rigid templates scattered across separate tools, and every change, however small, queued behind IT. The dependency frustrated the developers as much as the scriptwriters, and it bit hardest during product launches, when scripts needed to change fastest.
Fig. 01One outbound script, drawn to scale
What any replacement had to handle
- 01Routes by customer state from the first screen. Branching is the script's spine, not an edge case.
- 02Consent and do-not-call exits, reachable from anywhere. A missed connection had to surface before launch, not on a live call.
- 03One offer menu fans into eight product paths. Writers needed to build once and reuse, not copy.
- 04Three payment types, each with its own routing rules. Logic only engineering could touch.
Journey mapping: a process the writers didn't own
I synthesized findings into a swim-lane workflow covering concept to deployment. It helped the team align on where time was being lost and where design could move the needle.
Fig. 02Concept to live, and who held the pen
Where each phase stopped
- 01waits on SME direction
- 02waits on stakeholder feedback, then legal and SME sign-off
- 03 06waits in the engineering queue
- 04waits on the next build
- 05waits on test-environment time
- 07waits on fresh call data
Synthesis: four problems, one price
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.
03 / 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
04 / Ideation
Sketching the fix with the people it was for
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?
Fig. 03The session, and what came out of it
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.
05 / 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.
Fig. 04The coded prototype under test

The four fixes
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.
06 / Outcome
Scriptwriters took over. The numbers followed.
The redesign cut script deployment time from 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.




Speed to market has been the biggest benefit we've derived from the SingleComm tool.Lee Swanson, SVP of Telemarketing, Beachbody
Next case study

ColorPages·Generative AI·Creative tools
Designing around AI’s character consistency problem.
Read case study