.png)
Frameworks, core principles and top case studies for SaaS pricing, learnt and refined over 28+ years of SaaS-monetization experience.
Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.
MaxDiff analysis (Maximum Difference Scaling), also called best-worst scaling, is a research method that asks respondents to identify the most and least important items from sets of options. It produces a precise ranking of features, benefits, or messages based on customer preferences—making it ideal for SaaS companies that need to prioritize product roadmaps, refine value propositions, or optimize messaging without the complexity and cost of full conjoint analysis.
Introduction
Your backlog is overflowing with feature requests. Sales wants “just one more integration.” Marketing wants a new value prop on the homepage. Customers say everything is “very important.”
Yet your roadmap only has room for a few bets each quarter. If you’re relying on gut feel, loudest stakeholder, or a messy spreadsheet of “5-star” survey results, your priorities might be completely wrong.
That’s where MaxDiff analysis comes in.
MaxDiff (Maximum Difference Scaling), also known as best-worst scaling, helps you understand what actually matters most to your customers—across features, benefits, and messages—by forcing real trade-offs. Instead of asking “How important is this?” for every item, you ask “Which is most important, and which is least?” in many small sets.
For B2B SaaS teams, MaxDiff is especially powerful for:
- Feature prioritization for your product roadmap
- Value proposition testing and homepage messaging
- Packaging and tier decisions (which features go where)
This guide is for product managers, founders, and marketers (especially at $500K–$50M ARR) who need something more reliable than simple surveys, but less heavy and expensive than full conjoint pricing studies. Think of MaxDiff as the “Goldilocks” method: robust enough to be trusted, accessible enough to actually use.
What is MaxDiff Analysis?
Simple definition in plain English
MaxDiff analysis is a survey-based method where respondents repeatedly see small sets of items (e.g., features, benefits, messages) and pick:
- The most important (best)
- The least important (worst)
From these repeated best-worst choices, you get:
- A clear, quantified prioritization of all items
- Scores that show relative importance (e.g., Feature A is twice as preferred as Feature B)
- Rankings you can directly use to inform your roadmap, messaging, and packaging
In other words, instead of asking customers if something is important, MaxDiff shows you what they’d give up when forced to choose.
Alternative name: Best-Worst Scaling
You’ll see MaxDiff referred to as:
- MaxDiff (Maximum Difference Scaling)
- Best-worst scaling
They’re the same thing. “MaxDiff” is more common in commercial research tools; “best-worst scaling” is the academic term.
The core principle: forced trade-offs reveal true preferences
The key idea behind MaxDiff:
When people are forced to pick one best and one worst item from a set, those trade-offs reveal their true priorities much more clearly than rating everything on a 1–5 scale.
Instead of:
“Everything is 4 or 5 out of 5 in importance.”
You get:
“These 5 features are critical. These 5 are nice-to-have. These 10 can wait or be cut.”
MaxDiff minimizes:
- Scale bias – Some people never select “very important,” others select it for everything.
- Leniency bias – Respondents trying to be nice and rate all your ideas highly.
- Cognitive overload – Having to rank 20 items in order is painful and unreliable.
Brief history (Louviere 1991)
MaxDiff was developed by Jordan Louviere in the early 1990s as a more powerful alternative to typical rating scales. It’s been heavily used in consumer research and has become a standard in tools like Sawtooth Software and Qualtrics for feature prioritization, brand studies, and more.
You don’t need to know the math, but it’s well-established, statistically robust, and widely used by professional researchers.
Why it works better than rating scales
Traditional importance surveys ask: “How important is X?” for each feature on a rating scale. In SaaS, this usually leads to:
- 80–90% of features being labeled “important” or “very important”
- No real separation between the top 5 and the next 15
- Stakeholders arguing over tiny differences in average scores
MaxDiff works better because:
- It forces trade-offs – Respondents can’t say “everything is important.”
- It’s easier cognitively – Choosing best and worst from 4–5 items is simple and fast.
- It gives interval-level scores – You get relative importance values, not just averages.
For example, instead of:
- Feature A = 4.5
- Feature B = 4.4
- Feature C = 4.3
You get:
- Feature A = 100 (baseline)
- Feature B = 72
- Feature C = 35
Now you can clearly see Feature A isn’t just “slightly better”—it’s significantly more preferred.
How MaxDiff Analysis Works
The basic methodology: showing sets and asking for best/worst
At a high level, a MaxDiff survey works like this:
- You create a list of items you want to prioritize (typically 12–30).
- The survey tool creates a design that shows small sets of 3–6 items at a time (4–5 is most common).
- For each set, respondents answer two questions:
- “Which of these is most important to you?”
- “Which of these is least important to you?”
- Each respondent sees multiple sets (often 8–15 questions), with items rotated so each appears several times in different combinations.
- A statistical model then estimates a preference score for each item per respondent, and then aggregates these across respondents.
Visual: Sample MaxDiff question (SaaS feature example)
Imagine you’re prioritizing features for a project management SaaS. A MaxDiff question might look like:
Q3. Of the features below, which is MOST important and which is LEAST important when choosing a project management tool?
- Real-time collaboration on tasks
- Native integrations with Slack and Teams
- Automated workload balancing across team members
- Advanced reporting and analytics
- Custom client-facing dashboards
[ ] Most important: (select one)
[ ] Least important: (select one)
The respondent might choose:
- Most important: Real-time collaboration on tasks
- Least important: Custom client-facing dashboards
In another question, they’d see a different set of 4–5 features from your list, and do the same.
Real example walkthrough (conceptual)
Let’s say you’re testing 16 potential features for your B2B SaaS. You:
- Use a MaxDiff design with 5 items per set
- Show each respondent 12 sets
- Each feature appears 3–4 times across different combinations
After 250 responses, your MaxDiff analysis might show:
- Feature 7: 100 (most preferred)
- Feature 3: 82
- Feature 11: 76
- Feature 2: 45
- Feature 9: 15
- Feature 14: 5
You now have:
- A ranked list from 1 to 16
- Relative scores you can interpret (Feature 7 is ~2x as important as Feature 2)
- The ability to view scores by segment (e.g., SMB vs Enterprise)
What the math does: calculating utility scores
Under the hood, MaxDiff uses models (often Hierarchical Bayes or multinomial logit) to estimate each item’s utility—a numerical representation of its preference or importance.
You don’t have to run this manually—MaxDiff software does it for you. But conceptually:
- Each best choice gives an item “credit”
- Each worst choice gives an item a “penalty”
- The model looks at all choices across all sets and respondents
- It assigns each item a score that best fits the observed best/worst patterns
These utilities are then:
- Rescaled (often so the average is 0 or the top item is 100)
- Presented as importance scores that sum to 100 or are relative to the top item
From scores to actionable rankings
A good MaxDiff report will give you:
- Rank-ordered list of items
- Relative importance scores (e.g., 0–100 scale)
- Confidence intervals to understand uncertainty
- Segment-level results (e.g., by plan, company size, role, or industry)
You can then:
- Define top-tier features (e.g., scores > 70) as “must-haves”
- Identify mid-tier features for “nice-to-have” or higher-tier packaging
- Flag low-tier features (e.g., scores < 20) as deprioritized or removed
Why MaxDiff Works Better Than Traditional Surveys
The problem with rating scales (everything is “very important”)
In SaaS feature surveys, rating scales often fail because:
- Respondents don’t want to “hurt your feelings”
- They find it safer to rate most items as 4 or 5 out of 5
- Different respondents use the scale differently, making comparisons messy
The result: a wall of “very important,” and you’re no closer to knowing what to build first.
The problem with ranking exercises (cognitive overload)
Rank-all-items tasks (e.g., “Rank these 20 features from 1 to 20”) are:
- Hard to do accurately—people get tired and start rushing
- Especially noisy in the middle and bottom ranks
- Sensitive to ordering effects and how options are displayed
Most people can clearly pick their top 3–5 and bottom 2–3, but forcing them to fine-rank everything ruins data quality.
How MaxDiff eliminates response bias
MaxDiff improves data quality because:
- It forces trade-offs – You can’t say everything is top priority.
- Each decision is simple – Just pick best and worst from a small set.
- It reduces halo effects – Respondents don’t evaluate all items side by side in one list.
That combination produces:
- Better discrimination between items
- More trustworthy relative preferences
Statistical advantages: better discrimination between items
Because MaxDiff leverages repeated forced choices:
- It can clearly separate items that would otherwise look similar on a rating scale
- It produces interval-scale data, allowing stronger comparisons (e.g., “twice as preferred”)
- It supports robust segmentation analysis, because each respondent provides many discrete choices
Real data comparison: MaxDiff vs rating scale results
A typical pattern we see in B2B SaaS:
Rating scale survey:
18 of 22 features with average importance between 4.2 and 4.7
Leadership arguing over microscopic differences (4.45 vs 4.51)
MaxDiff on the same 22 features:
Top 4 features capturing ~50–60% of total importance
Bottom 8 features capturing <10% combined
Two “pet features” from internal stakeholders ranking near the bottom
The MaxDiff results lead to clear decisions: “We’ll ship these 4 first, these 6 next, and park the rest.”
Common Use Cases for MaxDiff in SaaS
1. Feature prioritization for product roadmap
Goal: Decide which features to build next.
Example:
A workflow automation SaaS has 24 feature ideas across:
- New integrations
- Admin controls
- Advanced analytics
- Workflow templates
Using MaxDiff, they discover:
- “Advanced role-based permissions” and “audit logs” rank far above new integrations for enterprise buyers.
- “Pre-built workflow templates” are much more important for SMB users than expected.
Outcome: The team prioritizes security and templates over additional integrations and sees improved enterprise win rates and SMB activation.
2. Value proposition and messaging testing
Goal: Identify which benefits and messages resonate most for your homepage, ads, and sales decks.
Example:
A developer tooling company tests 18 benefit statements, including:
- “Catch bugs earlier in the CI pipeline”
- “Reduce deployment failures by 40%”
- “Improve developer happiness”
- “Shorten onboarding for new engineers”
MaxDiff reveals that:
- “Reduce deployment failures” and “shorten onboarding” dominate.
- “Improve developer happiness,” while nice, ranks low as a primary value prop.
Outcome: Homepage copy and ad campaigns pivot to deployment reliability and onboarding speed, improving click-through and demo requests.
3. Benefit ranking for marketing copy
Goal: Decide which 3–5 benefits to highlight in marketing assets.
Example:
A billing SaaS wants to tighten its product page. They test 15 benefits spanning:
- Revenue recovery
- Time savings
- Error reduction
- Better reporting
MaxDiff shows that CFOs care most about “recovering failed payments automatically” and “reducing billing errors,” while ops leaders care more about “saving finance team hours.”
Outcome: They create role-specific landing pages and sales messaging tailored to each segment’s top benefits.
4. Competitive differentiator identification
Goal: Understand which differentiators actually matter vs. “nice bragging rights.”
Example:
A sales engagement platform compares its strengths vs. competitors across 20 possible differentiators.
MaxDiff reveals:
- “Native Salesforce integration without custom code” is 3x as important as “AI-generated email suggestions.”
- “Compliance and data residency options” rise to the top for regulated industries.
Outcome: Positioning and sales decks shift from generic “AI-powered” claims to concrete differentiators that drive deals.
5. Packaging and tier optimization
Goal: Decide which features belong in which tier (e.g., Basic, Pro, Enterprise).
Example:
A customer success platform considers how to package 25 features across 3 tiers.
MaxDiff shows:
- A cluster of features (SLAs, advanced reporting, SSO) are consistently “must-have” for larger accounts.
- Some low-cost to build features (e.g., in-app NPS survey) are surprisingly high value to SMBs.
Outcome: They move certain high-value, low-cost features into lower tiers to boost perceived value while reserving truly enterprise-critical capabilities for higher tiers.
6. Brand perception and positioning studies
Goal: Learn which brand attributes customers associate with you and which you should lean into.
Example:
A cloud security SaaS tests 18 attributes (e.g., “reliable,” “innovative,” “enterprise-ready,” “simple to use”).
MaxDiff reveals:
- Current customers strongly associate the brand with “reliable” and “enterprise-ready.”
- The team wants to be known for “innovative,” but it ranks low.
Outcome: They lean into “reliability at scale” in messaging while planning long-term product and marketing investments to credibly own “innovation” over time.
When to Use MaxDiff Analysis
Ideal scenarios and company stages
MaxDiff is especially useful when:
- You have more good ideas than capacity to build them
- You’re revisiting your positioning or value prop
- You’re planning a new pricing or packaging rollout
- You want evidence to push back on internal pet projects
It’s a great fit for:
- Growth-stage SaaS ($1M–$50M ARR) aligning product and GTM
- Seed/Series A companies refining their initial positioning
- Mature companies entering new segments or launching a major product update
Budget considerations (more accessible than conjoint)
Compared to conjoint analysis:
- MaxDiff is typically cheaper to design and run
- You can often use standard survey tools with MaxDiff modules
- Analysis is more straightforward and less time-consuming
For many SaaS teams, MaxDiff delivers 80–90% of the insight they need at a fraction of conjoint’s complexity and cost.
Timeline: faster than full conjoint studies
Typical MaxDiff project timeline:
- Scoping & design: 3–5 days
- Survey programming & testing: 2–4 days
- Fielding: 3–7 days
- Analysis & recommendations: 3–5 days
Total: 2–3 weeks from kickoff to decisions, versus 4–8 weeks for more complex conjoint work.
Minimum requirements: sample size, item count
As a rule of thumb:
- Item count: 12–30 items works best; 15–25 is the sweet spot
- Items per set: 4–5 usually; rarely more than 6
- Sample size:
- 150–250 completes for directional insights
- 300–500+ if you want solid segmentation (e.g., SMB vs Enterprise)
If you have fewer than ~100 qualified respondents, MaxDiff can still work, but you’ll mainly look at overall results, not detailed segments.
When NOT to use it
Avoid MaxDiff when:
- You need price elasticity or willingness-to-pay estimates (use conjoint instead)
- You need to model complex feature bundles and trade-offs (again, conjoint)
- You’re just doing qualitative discovery (use interviews first)
- Your item list is extremely vague or mixed (e.g., combining features, brand attributes, and pricing concepts in one list)
MaxDiff tells you what matters most within a defined set of items, not how customers will respond to complete offers with prices attached.
Decision framework: MaxDiff vs other methods
Use MaxDiff when:
You want to prioritize a list (features, benefits, messages)
You need a clear ranking and relative importance
You don’t need price trade-off modeling
Use Conjoint when:
You’re designing offers and pricing
You want to know how price, feature sets, and other attributes interact
You need market share or revenue simulations under different scenarios
Use simple surveys / ratings when:
You’re very early stage and just want directional input
You have only a small number of items (e.g., 4–6)
MaxDiff vs Conjoint Analysis
What conjoint does that MaxDiff doesn’t
Conjoint analysis is designed to answer questions like:
- “How much more will people pay for Feature X?”
- “Which combination of features and price maximizes revenue?”
- “What market share could we capture with Offer A vs Offer B?”
Conjoint shows respondents complete product configurations with prices and asks them to choose between them. It can:
- Estimate willingness to pay
- Model trade-offs between features, price, brand, etc.
- Simulate market scenarios (e.g., if we change price by 20%, what happens?)
MaxDiff does not do that. It focuses purely on relative importance within a list.
What MaxDiff does better
MaxDiff tends to be:
- Simpler to design and explain to stakeholders
- Easier on respondents (fewer complex choice tasks)
- Faster and cheaper to execute and analyze
For many SaaS decisions—especially feature prioritization and messaging—MaxDiff gives you exactly what you need without the overhead of conjoint.
Complexity and respondent burden comparison
MaxDiff:
Task: Choose most and least important from small sets
Cognitive load: Low to moderate
Good for: Long lists of features/benefits
Conjoint:
Task: Choose between complete product offers (with multiple attributes + price)
Cognitive load: Moderate to high
Good for: Pricing and packaging, product/price trade-offs
Sample size and cost comparison
MaxDiff:
Sample: 200–500 is often enough
Cost: Lower (simpler design, shorter surveys, easier analysis)
Conjoint:
Sample: Often 300–800+ for robust simulations and segments
Cost: Higher (specialized design and advanced modeling)
When to choose each method
Choose MaxDiff when:
- You’re prioritizing feature ideas or messages
- You’re updating positioning or value props
- You’re exploring which attributes matter before pricing work
Choose Conjoint when:
- You’re designing or revising pricing and packaging
- You need to predict revenue impact of pricing changes
- You’re comparing complete offers or bundles
Can you use both? (Yes, complementary)
Many mature SaaS companies use both:
- MaxDiff first to narrow down which features/benefits really matter.
- Conjoint next to design pricing and packaging around those high-value items.
This staged approach avoids bloated conjoint studies and keeps your research focused.
Real-World Example: B2B SaaS Feature Prioritization
Anonymous case study setup
A B2B SaaS platform (Series B, ~$12M ARR) in the HR tech space had:
- 20+ serious feature ideas
- Strong internal disagreement on priorities
- Limited dev capacity (one major release per quarter)
They’d been relying on:
- Ad-hoc feedback from sales calls
- A basic “rate each feature 1–5 in importance” survey
Every feature came back as “important.” No one felt confident cutting anything.
The business challenge
They needed to:
- Identify the 5–7 highest-impact features for the next 2 quarters
- Understand differences by segment (SMB vs mid-market vs enterprise)
- Gain data-backed leverage to push back on internal pet projects
Study design: items, sample, methodology
- Items tested: 22 feature concepts across analytics, workflows, integrations, and employee experience
- Audience: 350 existing customers across 3 segments
- Method: MaxDiff with 5 items per set, 12 sets per respondent
- Segments:
- SMB (<100 employees)
- Mid-market (100–999)
- Enterprise (1000+)
Results: top 5 vs bottom 5 features
Across all customers, the top 5 features were:
- Automated compliance alerts and audit trails
- Native payroll integration (no manual exports)
- Role-based access controls and granular permissions
- Pre-built compliance reports for audits
- Centralized employee document management
The bottom 5 features were:
- Employee social feed
- Custom profile backgrounds and themes
- Gamification badges
- Internal “shout-out” wall
- Advanced custom emoji reactions
Internal stakeholders had been heavily pushing the social/gamification features.
The surprise findings
Enterprise customers placed massive weight on:
- Compliance
- Security
- Integration
SMB customers still cared more about ease and speed than social features. The “fun” features that had dominated internal conversations were near the bottom for actual customers.
Business impact
Armed with MaxDiff results, the team:
- Re-prioritized the roadmap around compliance and integrations
- Defered most employee “engagement gimmicks” to later
- Repositioned their product as a compliance-forward HR platform
Outcomes within 2 quarters:
- Higher win rates in mid-market and enterprise deals
- Shorter sales cycles where compliance was a core requirement
- Clearer alignment between product, sales, and marketing
Running a MaxDiff Study: Step-by-Step Process
Step 1: Define research objectives
Be specific:
- “Prioritize 20 backlog features for our next 2–3 quarters.”
- “Identify the top 8–10 messages for our homepage and ads.”
- “Rank 18 potential differentiators for our new positioning.”
Clear objectives guide which items you include and how you segment results.
Step 2: Create your item list (12–30 items typically)
Brainstorm and refine:
- List all potential features, benefits, or messages
- Remove duplicates and overlaps
- Combine overly similar items into one clear statement
Aim for 15–25 well-defined items.
Step 3: Write clear, mutually exclusive items
Each item should:
- Be specific (avoid vague concepts like “better performance”)
- Refer to one idea (no “and/or” combos)
- Be easy for respondents to understand in 3–5 seconds
Quick Tip:
If you struggle to explain the item in plain language, it’s probably not survey-ready.
Step 4: Determine experimental design (sets, items per set)
Most SaaS MaxDiff studies use:
- Items per set: 4 or 5
- Sets per respondent: 8–15
- Design: Balanced so each item appears multiple times and with a variety of other items
Your software (Sawtooth, Qualtrics, etc.) will generate this design automatically once you specify:
- Total items
- Items per set
- Number of sets per respondent
Step 5: Calculate required sample size
Rules of thumb:
- General prioritization, no heavy segmentation: 150–250 completes
- Prioritization with 2–3 key segments: 300–500 completes
- Multiple segments + high precision needs: 500–800+
If you have limited budget or reach, it’s better to:
- Reduce item count slightly than accept very low sample sizes
- Focus on your most critical segment(s) first
Step 6: Build the survey
Your survey should include:
- Introduction & consent
- Screeners (ensure you’re talking to target users/buyers)
- Context questions (e.g., current tools, role, company size)
- MaxDiff exercise
- Follow-up questions (optional, e.g., open-ended feedback)
- Demographics / firmographics
Common Mistake:
Don’t overload the survey with extra rating scales and long grids before MaxDiff. Keep respondents fresh for the core task.
Step 7: Recruit respondents (targeting considerations)
Options:
- Your current customers (via email invites or in-product prompts)
- Prospects on your list
- Panels (for net-new audiences or competitive category research)
Make sure you:
- Clearly define who you want (role, industry, company size, buyer vs user)
- Avoid incentivizing speed over quality (too high rewards can backfire)
Step 8: Analyze results and create outputs
Your MaxDiff outputs should include:
- Overall rankings and scores
- Confidence intervals to see which items are truly different
- Segment splits (e.g., SMB vs Enterprise, product-qualified vs not, etc.)
- Visuals like bar charts of importance scores or share-of-preference
Quick Tip:
Create a simple chart with items sorted by importance, and a line marking your “must build” threshold.
Step 9: Translate findings into action
Turn results into concrete decisions:
Roadmap:
Tier 1 (must build): Top X features
Tier 2 (consider): Middle group
Tier 3 (defer/cut): Bottom group
Messaging:
Homepage hero and subhead from top 3–5 benefits
Supporting copy and proof points from mid-tier items
Packaging:
High-importance, high-cost items reserved for premium tiers
High-importance, low-cost items used to strengthen all tiers
Align your PM, marketing, and sales teams around the same prioritization view.
Typical timeline (2–3 weeks total)
- Week 1: Objectives, item list, survey design
- Week 2: Programming, soft launch, and full fielding
- Early Week 3: Analysis and internal workshop to align on decisions
Best Practices and Common Mistakes
Writing good items: clear, specific, mutually exclusive
- Avoid jargon where possible
- Test wording with 3–5 internal people not deeply involved in the project
- Make sure two items don’t essentially mean the same thing
Optimal number of items (sweet spot: 15–25)
- Fewer than ~12: MaxDiff is overkill; simple ranking might suffice
- More than 30: Respondent fatigue and weaker precision
If you have a long list, first run a workshop or quick internal sort to narrow down.
Items per set (typically 4–5)
- 3 items per set: very easy, but less efficient
- 4–5 items per set: best balance for B2B SaaS
- 6+ items per set: only if your audience is very engaged and skilled with complex tasks
Sample size requirements (rules of thumb)
- 200–300: Good for overall prioritization
- 300–500: Good for 2–3 segments
- 500+: For more granular segmentation or high-stakes decisions
Don’t mix different types of items
Avoid combining:
- Features
- Pricing concepts
- Brand attributes
- High-level value props
in a single MaxDiff. Each exercise should focus on one type (e.g., features OR benefits OR brand attributes).
Account for audience segments
Plan segmentation up front:
- Role (e.g., buyer vs end user)
- Company size (SMB vs mid-market vs enterprise)
- Current plan (Starter vs Pro vs Enterprise)
Design your sample and survey to ensure you have enough responses in each key segment you care about.
Test your survey before full launch
Soft launch to 10–20 respondents (or internal team) to:
- Confirm clarity of items
- Check survey length
- Validate MaxDiff task flow and any logic
Fix any confusion before you send it to hundreds of customers or a paid panel.
Tools and Software for MaxDiff
Sawtooth Software
- Pros: Most robust MaxDiff and conjoint platform, flexible design options, powerful analysis tools.
- Cons: Steeper learning curve, more suited to teams with research/analytics support.
Best for: Companies doing regular, sophisticated research and wanting full control.
Qualtrics
- Pros: Integrated MaxDiff module, easy survey building, strong reporting.
- Cons: Can be expensive; some advanced options gated behind higher tiers.
Best for: Mid-to-large companies already on Qualtrics or with broader CX/research needs.
Conjointly
- Pros: Affordable, user-friendly interface, good documentation, built-in MaxDiff and conjoint.
- Cons: Less customizable than Sawtooth but fully sufficient for most SaaS use cases.
Best for: Growth-stage SaaS wanting power without heavy research overhead.
SurveyMonkey
- Pros: Familiar interface, basic MaxDiff capabilities on higher plans.
- Cons: Less powerful design and analysis options; may require exports for deeper analytics.
Best for: Simple, smaller-scale studies.
DIY with R or Python
- Pros: Maximum flexibility, no per-survey software costs.
- Cons: Requires strong technical and statistical skills; time-consuming to set up and maintain.
Best for: Data science teams or research-heavy organizations willing to invest in internal tooling.
When to DIY vs hire a consultant
DIY is reasonable when:
- You have a dedicated researcher or analyst familiar with MaxDiff
- The stakes are moderate and you can accept some learning curve
Consider hiring a consultant when:
- Decisions are high-stakes (e.g., major roadmap, repositioning, or packaging change)
- Your team is new to structured research
- You want help turning numbers into strategic recommendations
Typical costs vary from a few thousand dollars for a simple project to more for complex, multi-country or multi-method studies.
Interpreting MaxDiff Results
Understanding utility scores
You’ll typically get:
- Raw utilities: unscaled preference values (often centered around 0)
- Rescaled scores: transformed to a 0–100 or 0–10 scale
- Relative importance shares: sometimes expressed as percentages that sum to 100
Key point: Focus on relative differences, not absolute numbers.
- If Feature A = 80 and Feature B = 40 on a 0–100 scale, A is about twice as preferred as B.
Reading the output charts
Look for:
- Ranked bar charts with confidence intervals
- Segment comparisons (overlaying scores for different groups)
- Top-2 box views (e.g., top 5 features vs the rest)
Quick Tip:
Sort all charts from highest to lowest score. Visual ranking matters more than raw numbers.
Statistical significance and confidence intervals
Good MaxDiff tools will show:
- Error bars or confidence intervals around each score
- Whether differences between items are statistically significant
Use this to decide:
- Where there’s a clear separation (e.g., top 3 vs middle 10)
- Where items are roughly tied and should be treated similarly
Segmentation analysis (enterprise vs SMB, etc.)
Segment results can reveal:
- Different top features for SMB vs enterprise
- Distinct priorities for buyers vs daily users
- Shifts in value across industries or regions
Use segmentation to:
- Create segment-specific roadmaps where appropriate
- Tailor messaging and sales collateral to each audience
Translating scores into business decisions
Examples:
If the top 5 features account for 55% of total importance:
Focus next 2–3 sprints on those features.
Promote them prominently in marketing.
If a feature ranks low but is expensive to build:
Strong case to cut or postpone it.
If a feature ranks high and is cheap to build:
Easy win to boost perceived value quickly.
Example output walkthrough (simplified)
Say your top 10 features get scores:
- Real-time collaboration – 100
- Native Slack/Teams integration – 82
- Advanced access controls – 76
- Audit logs – 72
- Custom reporting – 60
- Pre-built templates – 44
- In-app chat support – 28
- Mobile app – 22
- Dark mode – 10
- Social feed – 4
Interpretation:
- Features 1–5: Core value drivers – invest and highlight.
- Features 6–8: Supporting features – nice to have, use for differentiation if cheap.
- Features 9–10: Low priority – build only if strategically important for niche segments.
Conclusion
MaxDiff analysis—also known as best-worst scaling—is a powerful, accessible way for SaaS teams to bring clarity to feature prioritization, value proposition testing, and packaging decisions. It sits perfectly between simple, noisy rating surveys and complex conjoint pricing studies.
When you:
- Have too many good ideas and not enough capacity
- Feel stuck between conflicting stakeholder opinions
- Want to make product and messaging decisions with confidence
MaxDiff gives you a clear, data-backed ranking of what your customers value most.
The ROI of getting your priorities right is huge: faster product-market fit, more effective messaging, and fewer wasted sprints on low-impact features.
Need help prioritizing features or testing your value proposition? Schedule a free 30-minute consultation to discuss whether MaxDiff analysis is right for your business and how we can help you get clear, actionable insights.