Usability Research Reducing Trial Friction:
15% Churn Reduction for Enterprise Cloud Database Pricing

SingleStore | Cloud Database Platform

Project at a Glance

Timeline 2 weeks (July 2021)
Team 1 Researcher (solo), Product, Design
Methods Unmoderated usability testing, Think-aloud protocol, Task scenarios
My Role Lead UX Researcher (end-to-end)
Impact
  • 15% churn reduction in trial users
  • Increased trial-to-paid conversion
  • Reduced support tickets about pricing

Overview

SingleStore's new credit-based pricing model was launching to simplify cluster creation for trial users. However, early beta feedback suggested confusion around how credits were applied, what "upgrade" meant, and how to estimate monthly costs.

This research aimed to identify usability friction in the credit purchase and cluster creation flow before launch, enabling the team to refine terminology and UI clarity to reduce support burden and improve conversion.

Problem & Business Context

SingleStore was transitioning from a traditional pricing model to a credit-based system to give users more flexibility and transparency. However, this introduced new complexity:

  • Pricing confusion: Users didn't understand if credits applied to compute, storage, or both
  • Terminology ambiguity: "Upgrade" implied changing plans rather than purchasing additional credits
  • Mental math burden: Users wanted automatic calculation of remaining credits, not manual estimation
  • Support risk: Unclear pricing could drive support tickets and erode trust

Product leadership needed to validate the new flow before launch to avoid conversion drops and support costs.

Users & Audience

Primary Users

  • Data Engineers setting up cloud databases for the first time
  • Software Developers evaluating SingleStore during free trial
  • Technical decision-makers assessing total cost of ownership
  • Experience levels: Mix of junior (1-3 years) to senior (8+ years) professionals

Secondary Stakeholders

  • Product Management: Launch readiness decisions
  • Customer Success: Support ticket prevention
  • Sales: Pricing clarity for enterprise conversations

My Role

As the solo UX Researcher on this project, I was responsible for:

  • Designing the unmoderated usability testing protocol and task scenarios
  • Recruiting 5 participants representing target user roles (data engineers, software developers)
  • Analyzing qualitative feedback using thematic coding to identify recurring pain points
  • Synthesizing findings into prioritized recommendations with severity ratings
  • Presenting actionable insights to Product and Design teams
  • Collaborating with Product to validate implemented changes post-launch

While I owned research execution end-to-end, success required close partnership with Product and Design. I collaborated with the Product Manager to validate that task scenarios reflected real trial user workflows—she flagged that most users configure clusters immediately after signup rather than exploring first, which informed scenario sequencing. After the first 3 participants, I shared preliminary findings with the Design team: the "Upgrade" confusion was unmistakable. They quickly mocked up alternative button labels ("Add Credits," "Purchase More Credits") which I tested with the remaining 2 participants. This rapid iteration loop—research finding → design hypothesis → validation—compressed what could have been a multi-month cycle into a 2-week sprint.

Scope & Constraints

  • Timeline: 2 weeks from protocol design to recommendations delivery — tight timeline driven by product launch deadline
  • Budget: No participant incentives (internal beta users volunteered)
  • Sample size: 5 participants (typical for usability studies, focused on identifying critical issues rather than statistical validation)
  • Prototype limitations: Figma prototype with limited interactivity — couldn't test all edge cases or error states
  • Launch pressure: Product team had tight deadline for release, requiring fast turnaround without sacrificing research rigor
  • Prototype limitations forced creative adaptation: The Figma prototype couldn't dynamically calculate remaining credits in real-time, so I manually updated values between participant sessions to simulate different scenarios (low balance, sufficient balance, edge cases). One participant tried to click the credit calculation field—expecting it to be interactive—and said, "Oh, this is just a mockup." I acknowledged the limitation honestly but asked: "If this were live and showed your remaining balance updating in real-time, would that change your purchasing decision?" Her response ("Absolutely—I'd know immediately if I need to add more credits now or can wait until next month") validated the feature's value despite prototype constraints.

Research Process

1

Protocol Design & Recruitment

Designed task-based scenarios simulating real workflows: (1) Sign up for free trial using 300 credits, (2) Configure and deploy a database cluster, (3) Understand estimated monthly credit usage, (4) Purchase additional credits when running low.

Recruited 5 participants via internal beta program representing financial services, aviation & aerospace, IT services, and communications industries.

Why This Approach: Task-based scenarios reveal friction users would encounter in real usage, while think-aloud protocol surfaces mental model mismatches.
2

Unmoderated Usability Testing

Conducted remote testing using Maze.co platform with participants completing tasks using Figma prototype. Think-aloud protocol captured reasoning and confusion points. Post-task questions probed comprehension of terminology.

Collected quantitative metrics: Task success rate, ease ratings (4.2/5 average), time on task.

Why This Method: Unmoderated testing allowed us to reach geographically distributed users quickly without scheduling friction, while capturing authentic first reactions.
What We Learned: Even when users completed tasks successfully (80% found it "very easy"), verbal feedback revealed underlying confusion that could drive future support tickets.
Unmoderated Testing Trade-off: Unmoderated testing meant I couldn't probe confusion in real-time. When one participant rated cluster creation as "very easy" (5/5) but wrote in open-ended comments, "Wasn't sure if 180 CR/month was just compute or also storage," I couldn't ask clarifying follow-up questions to understand the depth of confusion. This taught me to always include open-ended "tell us more" prompts immediately after quantitative ratings—otherwise I would have missed critical insights hidden behind seemingly positive task completion metrics.

The cluster creation flow tested with users: from initial signup through configuration to security settings

The 'upgrade' flow that caused terminology confusion — users expected to change cluster configuration, not purchase additional credits

3

Thematic Analysis

Analyzed qualitative feedback to identify patterns: (1) Terminology confusion — 4 of 5 users misunderstood "upgrade" as changing cluster configuration, not purchasing credits, (2) Mental math burden — 3 of 5 users requested automatic calculation of remaining credits, (3) Credit scope ambiguity — 2 of 5 users uncertain if credits applied to storage costs.

Applied severity ratings based on frequency (how many users experienced the issue) and impact (how much it eroded trust or blocked task completion).

Why This Approach: Severity framework ensured we prioritized fixes that would have the greatest impact on conversion and support reduction.
4

Recommendations & Implementation

Delivered 3 prioritized recommendations: (1) Change "Upgrade" terminology to "Add Credits" or "Purchase More Credits", (2) Show remaining credit calculation with "You'll have X credits remaining after this purchase", (3) Clarify credit application with tooltip: "Credits apply to compute usage; storage billed separately".

Product team implemented recommendations #1 and #2 fully, and #3 as light guardrails plus just-in-time messaging. I worked directly with the Product Manager to prioritize fixes based on implementation complexity and impact. "Add Credits" was a simple label change (shipped in 2 days), while automatic credit calculation required backend logic (2-week sprint). Engineering initially suggested deferring #3 (credit scope clarity via tooltips) to a later release, but I made the case that tooltip copy was low-effort/high-impact—they agreed and shipped it with the initial fix. This collaborative prioritization ensured we addressed the highest-impact issues without delaying launch.

Why This Worked: Clear, actionable recommendations with user quotes made the business case compelling for fast implementation before launch.

Participant feedback showing confusion about "Est. Usage per Month

Key Findings

🔄

"Upgrade" Terminology Was Misleading

Users expected "Upgrade" to mean changing cluster size/configuration, not purchasing additional credits. 4 of 5 participants expressed confusion, which could block users from purchasing credits when trials ran out.

🧮

Users Wanted Automatic Math

UI showed "Est. Usage: 180 CR/month" and "Credit Balance: 300 CR" but didn't calculate "Remaining: 120 CR after 1 month." 3 of 5 users requested this feature to reduce anxiety about unexpected charges.

Credit Scope Was Unclear

Users didn't know if credits applied to compute only or also storage. 2 of 5 users asked explicitly. Uncertainty about total cost could block purchase decisions or drive support tickets.

Overall Flow Was Clear

80% of participants rated cluster creation as "very easy" (5/5). The happy path worked well — issues were isolated to specific terminology and information gaps rather than fundamental workflow problems.

💳

Billing Transparency Mattered

Users wanted visibility into exactly what they'd be charged for before committing. One user said: "Setting that would allow me to 'pause' the service if I ran out of credits, rather than charge me."

📊

Context Helped Decision-Making

When credit estimates were clearly labeled with context (e.g., "Based on 24/7 usage for 30 days"), users felt more confident. Ambiguous labels like "Est. Usage per Month" caused uncertainty.

Evidence: "Upgrade" Terminology Created Confusion

Impact & Outcomes

Business Impact

  • 15% churn reduction in trial users after implementation of recommendations
  • Increased trial-to-paid conversion (statistically significant improvement, exact percentage confidential)
  • Reduced support tickets about credit pricing and billing questions

Product Changes Implemented

  • Replaced "Upgrade" button with "Add Credits" to clarify intent
  • Added real-time calculation displaying "After this purchase, you'll have X credits remaining"
  • Added tooltips and just-in-time messaging clarifying credit application to compute vs. storage
  • Implemented light guardrails to prevent unexpected charges when credits ran out

Organizational Impact

  • Established pattern for rapid usability testing before feature launches
  • Built trust between Research and Product teams through fast, actionable insights
  • Created reusable protocol for testing pricing and billing flows in future releases

Deliverables

  • Usability testing protocol with task scenarios, screening criteria, and think-aloud instructions
  • Findings presentation deck with user quotes, severity ratings, and prioritized recommendations
  • Prioritization framework linking findings to business risk (conversion, support tickets, churn)
  • Post-launch validation confirming implementation matched research intent

Reflections & What I'd Do Differently

What Worked Well

  • Unmoderated testing: Enabled fast turnaround within tight launch timeline without sacrificing quality
  • Severity framework: Helped Product prioritize fixes with highest impact on business metrics
  • Think-aloud protocol: Revealed issues that task completion metrics alone would have missed — users succeeded but were still confused

What I'd Do Differently

  • Larger sample size: 8-10 participants would have increased confidence in findings and revealed edge cases
  • Follow-up study: Post-launch usability testing to validate that changes actually resolved confusion in production
  • Quantitative baseline: Pre-launch metrics on support ticket volume would have strengthened the impact story
  • Broader scenarios: Test edge cases like credit exhaustion, billing disputes, and refund requests

Skills Demonstrated in This Project

Unmoderated Usability Testing
Task-Based Research
Think-Aloud Protocol
Thematic Analysis
Severity Rating Frameworks
Rapid Research (2-week turnaround)
Stakeholder Collaboration
Pricing & Billing UX
Enterprise Cloud Database
Conversion Optimization
Protocol Design
Figma Prototype Testing