Prototype Management

Silicon Valley Bank

How I Created Efficiency in How my Team Managed Prototypes

The Client Lifecycle Management (CLM) team at SVB was responsible for designing and building digital experiences to onboard new clients and help existing ones update their information. One key initiative was the Application Journey for new prospects.

Our Product Managers emphasized the need to:

  • Provide an always-available prototype of the end-to-end onboarding experience for SVB prospects so internal stakeholders could review it when the UAT environment was down.

  • Maintain a ready-for-development prototype as a reference for engineers.

  • Create future design iterations for ideation, internal testing, and decision-making.

Research & Challenges

Managing Multiple Versions of Copy

With the help of our Content Strategist, we had recently updated much of the content. The challenge was tracking different versions of the copy:

  1. The demo version for stakeholder presentations.

  2. The development-ready version for engineers.

  3. The experimental version for design iterations.

Complexity of Our Figma Prototype

Our Figma prototype was massive, documenting every interaction across nine screens, plus email designs and login screens. It relied on two interdependent design libraries — one for CLM and another for the broader product team.

  • Updates were time-consuming, requiring frequent synchronization whenever the Product Design System changed.

  • Managing updates took hours weekly, impacting efficiency.

Exploring Solutions

Ditto (Content Management Tool)

Ditto, a web app for managing copy, offered seamless integration with Figma and allowed tagging content across different design versions. No more messy copy docs, confusing back-and-forths, or endless copy/paste.

However, adoption was blocked due to:

  • Subscription costs.

  • Security requirements.

  • SSO setup hindered by engineering resource constraints.

  • Product leadership determining that SVB lacked the resources to support and maintain the software.

This was a disappointment.

Figma’s Built-in Capabilities as a Workaround

Branching

Figma allowed branching from an existing prototype, making it possible to:

  • Maintain a main branch for development.

  • Create a demo branch with stakeholder-friendly content.

  • Spin off work-in-progress (WIP) branches for experimentation.

Variables

Figma introduced variable strings (in beta), allowing us to manage different versions of copy dynamically. This enabled:

  • A Demo mode with stakeholder-facing copy.

  • A Ready mode with production-ready content.

  • Overrides in WIP branches without affecting the main design.

Implementation Plan

Set up variable strings:

1. Set up variable strings:

  • Created Demo variables in the CLM Figma library (using UAT copy).

  • Created Ready variables in the CLM Figma library (using Content Strategist-approved copy).

  • Replaced all static text blocks with variables.

2. Organized branches:

  • Maintained a main branch for development.

  • Created a demo branch with the correct variable mode applied.

  • Established a process for WIP branches, with URLs provided in Jira tickets.

3. Educated stakeholders:

    • Demo mode: Product Managers used the provided demo prototype link.

    • Ready mode: Engineers continued using the main prototype link.

    • WIP versions: Each new iteration was shared via Jira.

Results & Impact

  • Delivered a structured content management system without requiring Ditto.

  • Provided Product Management with an always-ready demo prototype.

  • Enabled Design to compare copy differences between main and demo branches.

  • Saved SVB $15/month by eliminating Ditto subscription costs.

Had SVB retained Content Strategists, collaborating on copy updates would have been seamless because of our new method of creating a WIP branch, refining content, and merging it into the main branch after approval.

Trade-offs & Future Potential

While this approach worked, Ditto offered an API for managing copy in development—a missed opportunity due to engineering resource constraints. Ditto’s full potential included:

  • Automated text updates via API.

  • GitHub Actions & webhooks for streamlined content changes.

  • Cross-team collaboration between Design, Content, and Development.

While I couldn’t implement this at SVB, I look forward to leveraging these capabilities in my next role to improve content workflow efficiency.