Product Use Cases

Real-world examples of contextual feedback questions that drive product insights. Each section includes the problem, sample questions, and implementation code.

Instant Insight Questions

These are the short, powerful questions that unlock deep product insights. Ask them immediately when users interact with your product for maximum context and honesty.

💡 What-If Feature Enhancement Pain

Pain: "Not knowing whether adding this burn-rate column would provide critical insights or just add visual noise to an already cluttered dashboard."

Question: "What if we had a burn-rate column here that tells you your spending with respect to time?"

When to ask: After users view spending/financial data

ask('burn-rate-insight', {
  context: { page: 'financial-dashboard', dataType: 'spending' }
});

Pain: "Uncertain whether trending topics would surface valuable conversations or overwhelm users with irrelevant noise in their feed."

Question: "What if we showed trending topics here based on what your network is discussing?"

When to ask: When users browse content feeds

ask('trending-topics-insight', {
  context: { section: 'content-feed', userInterests: user.topics }
});

🎯 Usage Pattern Discovery Pain

Pain: "Not knowing if this button is essential for user workflows or just visual clutter that nobody actually needs."

Question: "How often do you use this button?"

When to ask: On button hover or after multiple uses

ask('button-usage-frequency', {
  context: { button: 'export', usageCount: 5 }
});

Pain: "Unsure whether users ignore this feature because it's truly useless or because they simply haven't discovered its value yet."

Question: "How often have you used this feature in the past month?"

When to ask: When highlighting unused features to users

// Highlight unused feature and ask
if (featureNotUsedRecently) {
  highlightElement('#advanced-analytics');
  ask('feature-usage-frequency', {
    context: { feature: 'advanced-analytics', lastUsed: daysSinceLastUse }
  });
}

🚀 Feature Interest & Preference Pain

Pain: "Blindly prioritizing feature development without knowing which capabilities would actually excite and retain users."

Question: "Which of these features excites you the most right now?"

When to ask: After showing new feature announcements

ask('feature-excitement-ranking', {
  context: { features: ['ai-insights', 'auto-save', 'collaboration'], page: 'new-features' }
});

Pain: "Successfully completing tasks but unsure what single addition would transform a good experience into an exceptional one."

Question: "If you could add one feature to make this perfect, what would it be?"

When to ask: After successful task completion

ask('perfect-feature-addition', {
  context: { completedTask: 'report-generation', satisfaction: 'high' }
});

📝 Form Completion Enhancement Pain

Pain: "Forms collect data successfully but unclear which additional fields would provide insights without overwhelming users."

Question: "Any other detail that you'd like to have in this form?"

When to ask: Immediately after form submission for enhancement insights

ask('form-enhancement-ideas', {
  context: {
    form: 'fund-creation',
    fieldsCompleted: 8,
    timeToComplete: 45
  }
});

⚡ Process Efficiency Pain

Pain: "Users complete multi-step workflows but uncertain which bottlenecks could be eliminated to dramatically improve speed."

Question: "What would make this process twice as fast?"

When to ask: After completing multi-step workflows

ask('workflow-speed-improvement', {
  context: {
    workflow: 'onboarding',
    steps: 5,
    timeSpent: 180,
    completionRate: 0.8
  }
});

Pain: "Complex processes work but blind to which specific optimizations would deliver the biggest efficiency gains for users."

Question: "What's one thing we could do to make this workflow 2x faster?"

When to ask: After users complete complex processes

ask('workflow-optimization-idea', {
  context: {
    workflow: 'bulk-import',
    stepsCompleted: 4,
    timeSpent: 120,
    successRate: 0.95
  }
});

🎨 Interface Enhancement Pain

Pain: "Users spend time on dashboards but unclear which specific details would make the data more useful and actionable."

Question: "What detail would you add here to make this more useful?"

When to ask: When users spend time on dashboards or data views

if (dwellTime > 30) {
  ask('dashboard-enhancement', {
    context: { section: 'analytics', dwellTime, viewedMetrics: ['revenue', 'users'] }
  });
}

Pain: "Tasks complete successfully but uncertain what changes would elevate the experience from functional to delightful."

Question: "How would you improve this if you could change anything?"

When to ask: After users complete important tasks

ask('open-improvement-suggestion', {
  context: { task: 'invoice-creation', success: true }
});

🔍 Information Gap Pain

Pain: "Users search or browse extensively but unclear what information they expected to find that isn't currently available."

Question: "What were you hoping to find here that you didn't see?"

When to ask: When users search but get no results or spend time looking

if (searchNoResults || dwellTime > 20) {
  ask('missing-information-insight', {
    context: { searchQuery, page: location.pathname, timeSpent: dwellTime }
  });
}

🎯 Experience Priority Pain

Pain: "Multiple potential improvements compete for attention but unclear which single fix would have the biggest impact on user satisfaction."

Question: "If we could only improve one thing about this experience, what would it be?"

When to ask: At key decision points in user journeys

ask('priority-improvement-insight', {
  context: { journey: 'checkout', step: 'payment', conversionRate: 0.75 }
});

Major Product Pain Points

These are the high-stakes problems that cost companies millions. WhatIf provides the contextual insights needed to solve them.

🔍 Discovery & Adoption Pain

Pain: "Features built with great effort remain undiscovered, unclear whether better placement or promotion would improve findability."

Question: "How did you discover this feature?"

When to ask: When users first encounter a new feature

if (firstTimeSeeingFeature) {
  ask('feature-discovery-feedback', {
    context: { feature: feature.name, daysSinceSignup: user.daysSinceSignup }
  });
}

Pain: "Prominent features go unused, uncertain whether they lack value or simply haven't been presented compellingly enough."

Question: "Why did you decide not to try this?"

When to ask: When users see but don't interact with features

ask('feature-adoption-barrier', {
  context: { feature: feature.name, visibleTime: 30 }
});

Pain: "Features deliver some value but unclear what enhancements would make them indispensable rather than merely useful."

Question: "What would make this more useful to you?"

When to ask: After showing feature benefits but user remains uninterested

ask('feature-value-proposition', {
  context: { feature: feature.name, shownBenefits: ['saves-time', 'automates-work'] }
});

💸 Form & Conversion Pain

Pain: "Forms work but some users abandon midway, unclear whether field order, complexity, or timing causes drop-offs."

Question: "What made you stop midway?"

When to ask: When users abandon forms mid-completion

if (abandoningMidForm) {
  ask('form-abandon-feedback', {
    context: { field: currentField, step }
  });
}

Pain: "Form completion rates are good but uncertain which fields might be simplified or removed without losing valuable data."

Question: "Was any field confusing or too personal?"

When to ask: Immediately after form abandonment detection

ask('form-field-feedback', {
  context: { completedFields: 3, totalFields: 8, lastField: 'phone' }
});

👥 Onboarding Pain

Pain: "Onboarding completion rates are decent but unclear which steps cause confusion and could be simplified or reordered."

Question: "What's unclear in this step?"

When to ask: When users spend too long on onboarding steps

if (timeOnStep > MAX_EXPECTED_TIME) {
  ask('onboarding-clarity-issue', {
    context: { step, timeOnStep }
  });
}

Pain: "Users progress through onboarding but sometimes pause, uncertain whether friction points or natural breaks cause delays."

Question: "Is something stopping you from continuing?"

When to ask: When users pause during onboarding flow

ask('onboarding-blocker', {
  context: { step, previousSteps: [1, 2], timeInFlow: 120 }
});

Pain: "Users proceed through onboarding but unclear how confident they feel and whether the process builds proper understanding."

Question: "How confident do you feel right now?"

When to ask: At decision points in onboarding

ask('onboarding-confidence-check', {
  context: { step: 3, progress: 0.6, featuresIntroduced: 5 }
});

🔥 UX Friction Pain

Pain: "Some users show frustration with interactions but unclear whether these are UX issues or edge cases we haven't considered."

Question: "What were you trying to do here?"

When to ask: When rage clicks or errors are detected

if (rageClickDetected) {
  ask('rage-click-intent', {
    context: { element: '#submit-button', attempts }
  });
}

Pain: "Users sometimes struggle with interactions but uncertain whether labels, positioning, or workflow changes would improve clarity."

Question: "Was this interaction confusing?"

When to ask: After unexpected user behavior

ask('interaction-clarity', {
  context: { element: clickedElement, expectedAction: 'save', actualAction: 'delete' }
});

Pain: "Users occasionally encounter unexpected behavior but unclear whether this violates their mental model or represents valid edge cases."

Question: "Did something feel unexpected?"

When to ask: When users hesitate or make errors

ask('unexpected-behavior-feedback', {
  context: { action: 'file-upload', error: 'file-too-large', userAttempted: 3 }
});

📭 Empty State Pain

Pain: "Users reach pages with no content but unclear what they expected to find or what guidance would be most helpful."

Question: "What were you hoping to see here?"

When to ask: When users encounter empty states or zero results

if (results.length === 0) {
  ask('empty-state-expectation', {
    context: { query, filters, page: location.pathname }
  });
}

Pain: "Empty states show default messaging but uncertain whether custom guidance, tutorials, or alternative content would better serve users."

Question: "Is there something we should show instead when this is empty?"

When to ask: After users spend time on empty pages

ask('empty-state-improvement', {
  context: { dwellTime: 25, userType: 'power-user', previousActions: ['searched', 'filtered'] }
});

💔 Churn & Retention Pain

Pain: "Users show engagement decline but unclear whether this indicates real problems or natural usage patterns that don't require intervention."

Question: "Is something frustrating you?"

When to ask: When detecting early churn signals

ask('frustration-check', {
  context: { signal: 'slow-response', daysActive: 30, usageDecline: true }
});

Pain: "Some users show disengagement signals but uncertain whether they represent serious issues or temporary fluctuations."

Question: "What's the main reason you're thinking of leaving?"

When to ask: When users show disengagement signals

ask('churn-reason-discovery', {
  context: { cancellationStep: true, accountAge: 90, plan: 'pro' }
});

Pain: "Users reach cancellation points but unclear which specific improvements would actually convince them to stay."

Question: "What would need to change for you to stay?"

When to ask: During cancellation flow to gather retention insights

ask('retention-opportunity', {
  context: { step: 'final-cancellation', competitor: 'mentioned', feedback: 'slow' }
});

💰 Pricing Pain

Pain: "Users view pricing multiple times but don't upgrade, unclear whether they don't understand value or find the pricing unattractive."

Question: "Does this plan make sense to you?"

When to ask: After users spend time reviewing pricing

if (viewedPricingManyTimes && !upgraded) {
  ask('pricing-comprehension', {
    context: { timesViewed, currentPlan: user.plan, teamSize: user.teamSize }
  });
}

Pain: "Users reach upgrade points but hesitate, uncertain whether pricing, feature gaps, or timing issues cause reluctance."

Question: "What's your biggest hesitation about upgrading?"

When to ask: When users reach upgrade prompts but hesitate

ask('upgrade-barrier-discovery', {
  context: { targetPlan: 'enterprise', currentUsage: 85, limitHit: 'users' }
});

Pain: "Users stay on basic plans but unclear which premium features would actually justify the upgrade cost."

Question: "Which feature would make this worth it?"

When to ask: To understand what drives upgrade decisions

ask('upgrade-motivation-insight', {
  context: { planComparison: ['pro', 'enterprise'], missingFeatures: ['api', 'white-label'] }
});

😡 Error Pain

Pain: "Errors occur but users continue using the product, unclear whether they notice them or just work around them."

Question: "Did something just go wrong here?"

When to ask: When errors occur but users continue using the product

ask('error-awareness-check', {
  context: { errorCode, action: 'upload_file', userContinued: true }
});

Pain: "Users encounter errors and recover but unclear how frustrating the experience is and whether better messaging would help."

Question: "How frustrating was this?"

When to ask: After error recovery to measure impact

ask('error-frustration-level', {
  context: { error: 'timeout', recoveryTime: 15, userPatience: 'low' }
});

🤔 Unexpected Behavior Pain

Pain: "Users occasionally perform undo actions, unclear whether this indicates UX confusion or legitimate changes of mind."

Question: "Were you expecting something different to happen?"

When to ask: When users perform undo actions or show confusion

ask('expectation-mismatch-discovery', {
  context: { action: 'clicked-export', result: 'opened-modal', userUndid: true }
});

Pain: "Users interact with elements but unclear whether their mental model matches the intended functionality or if labels need improvement."

Question: "What did you think this would do?"

When to ask: To understand mental models and UX assumptions

ask('user-mental-model', {
  context: { element: '#share-button', expectedOutcome: 'unknown', actualOutcome: 'copy-link' }
});

🎯 Beta Validation Pain

Pain: "Beta features get usage but unclear whether users find them genuinely useful or are just exploring out of curiosity."

Question: "Is this useful to you?"

When to ask: During beta feature usage to validate value

if (betaFeatureUsed) {
  ask('beta-utility-assessment', {
    context: { feature: feature.name, usageCount, timeSpent }
  });
}

Pain: "Beta features have some engagement but uncertain whether users would actually miss them if removed or just adapt to alternatives."

Question: "Would you miss this if we removed it?"

When to ask: To measure feature attachment and necessity

ask('beta-indispensability-check', {
  context: { feature: 'ai-suggestions', alternatives: ['manual', 'templates'], satisfaction: 8 }
});

❓ Help & Documentation Pain

Pain: "Users interact with help content but unclear whether it actually helps them or if they dismiss it due to irrelevance."

Question: "Did this explanation help?"

When to ask: After users interact with help content

ask('help-content-effectiveness', {
    context: { tooltipId, dismissed: dismissedTooFast, timeRead: 8 }
});

Pain: "Users read documentation but sometimes struggle, uncertain whether content gaps or comprehension issues cause difficulties."

Question: "Was anything still unclear after reading this?"

When to ask: To identify gaps in documentation

ask('documentation-gap-discovery', {
  context: { helpTopic: 'api-setup', comprehensionLevel: 'partial', nextAction: 'gave-up' }
});

⚠️ Plan Limit Pain

Pain: "Users hit plan limits but unclear whether these genuinely block their work or represent unused buffer capacity."

Question: "Does this limit stop you from doing what you need?"

When to ask: When users hit usage limits

if (usingFeatureOverLimit) {
  ask('limit-impact-assessment', {
    context: { feature: 'reporting', usage: usageCount, limit: planLimit }
  });
}

Additional Use Cases

🔍 Information Discovery Pain

Pain: "Users spend time on pages but we don't know what they're looking for."

Sample questions:

• "Did you look for anything on this page that you couldn't find?"
• "What were you hoping to find here?"

if (longDwellDetected) {
  ask('missing-info-feedback', {
    context: { dwellTime, page: location.pathname, searchQuery }
  });
}

⚙️ Task Expectation Check

Pain: "Users perform actions but we're not sure if the results match their expectations."

Sample questions:

• "Was this exactly what you expected to happen?"
• "Did the result surprise you in any way?"

ask('expectation-check', {
  context: { action: 'export-report', result: exportStatus }
});

🧩 Missing Feature Insight

Pain: "Users want capabilities we haven't built yet."

Sample questions:

• "What did you hope to do here that you couldn't?"
• "Is there a feature you're missing?"

ask('missing-feature-desire', {
  context: { primaryActionAvailable, userRole: user.role }
});

📊 Dashboard Improvement Insight

Pain: "Dashboard data feels incomplete or unhelpful."

Sample questions:

• "What detail would you add here to make this more useful?"
• "What's missing from this view?"

ask('dashboard-improvement', {
  context: { dashboard: 'monthly-financials', filtersUsed }
});

📝 Setup Clarity Insight

Pain: "Users complete setup but remain confused about what they configured."

Sample questions:

• "Is anything still unclear about what you just set up?"
• "Do you understand how this works now?"

ask('setup-clarity-check', {
  context: { integration: 'slack-webhook', timeSpent }
});

⚡ Workflow Perception Insight

Pain: "We think workflows are efficient, but users feel they take too long."

Sample questions:

• "Did this workflow take longer than you expected?"
• "How did the timing feel?"

ask('workflow-duration-perception', {
  context: { workflow: 'report-generation', duration: timeSpent }
});

🧽 UI Clutter Insight

Pain: "Interfaces feel overwhelming but we don't know what to remove."

Sample questions:

• "Anything here feel unnecessary or distracting?"
• "What could we simplify on this page?"

ask('ui-clutter-feedback', {
  context: { section: 'settings-panel' }
});

🔄 Automation Opportunity

Pain: "Manual processes feel tedious but we don't know which to automate."

Sample questions:

• "Would you prefer this step automated?"
• "What repetitive tasks do you wish were easier?"

ask('automation-preference', {
  context: { action: 'tag-multiple-items', count: selectedItems.length }
});

🧠 Cognitive Load Mapping

Pain: "Forms feel complex but we don't know which parts are hardest."

Sample questions:

• "What part of this form made you think the longest?"
• "Which field felt most challenging?"

ask('thinking-load-feedback', {
  context: { form: 'payment-setup', fieldTimes: getFieldTiming() }
});

😮 Unexpected Experience

Pain: "Users encounter unexpected behavior but don't tell us."

Sample questions:

• "Was anything unexpected during this process?"
• "Did anything surprise you?"

ask('unexpected-experience', {
  context: { flow: 'import-csv', result: importResult, errors: importErrors }
});

Next Steps

• 📖 API Reference - Complete technical documentation
• 🎨 Theming Guide - Customize widget appearance
• 📊 Context Guide - Advanced context techniques