Rod Howard Résumé

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.

8 weeksAverage time from script concept to deployment
2–3 weeksTypical 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

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

Welcome Call back Permission I'll call you Customer service Graceful exit Take me off list End call Do not call Started 21-Day Fix Not started yet Solutions CC last 4 TBB Club One Pay Reg E confirm Card info Shipping Close Billing info Check Coach consent Non-order close End call Eight add-on offers 1 2 3 4
Thirty-plus screens and twenty-five-plus routing rules, rebuilt by hand in every system it touched.

What any replacement had to handle

  1. 01Routes by customer state from the first screen. Branching is the script's spine, not an edge case.
  2. 02Consent and do-not-call exits, reachable from anywhere. A missed connection had to surface before launch, not on a live call.
  3. 03One offer menu fans into eight product paths. Writers needed to build once and reuse, not copy.
  4. 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

CONCEPT 8 WEEKS END TO END LIVE WRITER ENGINEERING QA 01 Concept & plan 02 Author & revise 03 Build 04 Review & tweak 05 Test & validate 06 Deploy 07 Live & iterate
The writer authored the script but could not build it. Every tweak went back through engineering, and that loop is where the eight weeks went.

Where each phase stopped

  1. 01waits on SME direction
  2. 02waits on stakeholder feedback, then legal and SME sign-off
  3. 03 06waits in the engineering queue
  4. 04waits on the next build
  5. 05waits on test-environment time
  6. 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

How Might We ideation workshop output Workshop sketches from the ideation session
Three How Might We questions in, three design directions out, voted on by the people who would use them.

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

Script builder prototype demonstration
All five scriptwriters built a multi-path script unassisted. Four fixes came out of the sessions.

The four fixes

  1. 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.

  2. 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.

  3. 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.

  4. 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.

$100K+ a yearSaved for Beachbody alone by offloading scripting to business users.
8 weeks → 3 daysScript deployment time, after the new platform shipped.
Faster iterationFrom 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

Next case study

ColorPages·Generative AI·Creative tools

Designing around AI’s character consistency problem.

Read case study