Opportunity Score Formula: How to Calculate and Prioritize Product Opportunities

The Opportunity Score formula is Importance × (1 − Satisfaction), where both variables are normalized to a 0‑1 scale, producing a 0‑1 score that surfaces high‑value customer problems ripe for innovation.

The Opportunity Score is a prioritization metric introduced by Dan Olsen in The Lean Product Playbook. Product teams use it to rank potential features or assumptions by weighing how critical a problem is against how poorly it is currently solved. The phuryn/pm-skills repository documents this formula across multiple skill modules, providing both theoretical context and executable code samples.

Understanding the Opportunity Score Formula

The formula follows a simple multiplicative model designed to maximize impact:

Opportunity Score = Importance × (1 − Satisfaction)

The Two Input Variables

• Importance – A decimal value from 0 to 1 representing how critical the problem is to the target customer. A score of 0.9 indicates a severe pain point, while 0.2 reflects a minor annoyance.
• Satisfaction – A decimal value from 0 to 1 representing how well existing solutions address the problem. A score of 0.1 means current solutions are inadequate, whereas 0.9 indicates the problem is already well‑solved.

Because the formula multiplies Importance by the unsatisfied portion of the market (1 − Satisfaction), the highest scores emerge when a critical problem (high Importance) meets an underserved market (low Satisfaction).

Implementing the Calculation in Code

According to the phuryn/pm-skills source code, you can implement the Opportunity Score in any programming language using the same mathematical operation.

Python Implementation

The repository provides a concise Python function in pm-product-discovery/skills/prioritize-features/SKILL.md:

def opportunity_score(importance, satisfaction):
    """
    importance and satisfaction should be floats in the range [0, 1].
    Returns a score in the range [0, 1].
    """
    return importance * (1 - satisfaction)

# Sample data (importance, satisfaction)

problems = {
    "slow onboarding": (0.9, 0.3),
    "missing export feature": (0.6, 0.8),
    "poor search relevance": (0.8, 0.2),
}

# Compute scores

scores = {name: opportunity_score(imp, sat) for name, (imp, sat) in problems.items()}

# Sort by highest opportunity

ranked = sorted(scores.items(), key=lambda kv: kv[1], reverse=True)
print("Opportunities ranked by score:")
for name, score in ranked:
    print(f"{name}: {score:.2f}")

This script outputs:

Opportunities ranked by score:
poor search relevance: 0.64
slow onboarding: 0.63
missing export feature: 0.12

In this example, "poor search relevance" receives the highest Opportunity Score (0.64) because it combines high importance (0.8) with very low satisfaction (0.2).

JavaScript Implementation

For web‑based product management tools, the same logic applies:

function opportunityScore(importance, satisfaction) {
  return importance * (1 - satisfaction);
}

// Sample problems
const problems = {
  "slow onboarding": [0.9, 0.3],
  "missing export feature": [0.6, 0.8],
  "poor search relevance": [0.8, 0.2],
};

const scores = Object.entries(problems).map(([name, [imp, sat]]) => ({
  name,
  score: opportunityScore(imp, sat),
}));

scores.sort((a, b) => b.score - a.score);
console.log("Opportunities ranked by score:");
scores.forEach(p => console.log(`${p.name}: ${p.score.toFixed(2)}`));

Both implementations normalize inputs to the 0‑1 range and return a score that can be sorted descending to reveal the highest‑priority opportunities.

Where This Formula Appears in the pm-skills Repository

The phuryn/pm-skills repository references the Opportunity Score formula in several key locations:

• pm-product-discovery/skills/prioritize-features/SKILL.md – Contains the primary definition of the formula and explains its role in feature prioritization workflows.
• pm-product-discovery/skills/prioritize-assumptions/SKILL.md – Demonstrates how to apply the same calculation when ranking assumptions for validation, often alongside ICE or RICE frameworks.
• pm-execution/skills/prioritization-frameworks/SKILL.md – Lists the Opportunity Score as one of several prioritization methodologies available to product managers.
• pm-product-discovery/skills/opportunity-solution-tree/SKILL.md – Describes how the Opportunity Score integrates into the Opportunity Solution Tree framework, helping teams map problems to solutions quantitatively.

Summary

• The Opportunity Score formula is Importance × (1 − Satisfaction), producing a 0‑1 score.
• High scores indicate critical problems with poor existing solutions, representing the best opportunities for product investment.
• Both Python and JavaScript implementations require only a single arithmetic operation.
• The phuryn/pm-skills repository documents this formula across feature prioritization, assumption testing, and opportunity mapping skill modules.

Frequently Asked Questions

What is the Opportunity Score formula?

The Opportunity Score formula is Importance multiplied by (1 minus Satisfaction). Both inputs are normalized to values between 0 and 1, yielding a score in the same range. This calculation identifies problems that are both important to customers and currently underserved by existing solutions.

Who created the Opportunity Score?

Dan Olsen introduced the Opportunity Score in his book The Lean Product Playbook. He designed it as a quantitative method for product teams to objectively compare and rank potential opportunities based on customer data rather than intuition alone.

How do you interpret Opportunity Score results?

Scores closest to 1.0 represent the highest priority opportunities—these are urgent problems with inadequate current solutions. Scores near 0 indicate either low‑importance issues or problems that are already well‑solved. Teams should generally address opportunities scoring above 0.5 before investing in lower‑scoring items.

Can Opportunity Score be used for assumptions as well as features?

Yes. According to pm-product-discovery/skills/prioritize-assumptions/SKILL.md, the identical formula applies to assumption prioritization. Product teams can rate the importance of an assumption to business success and their current confidence (satisfaction) in that assumption to determine which hypotheses require immediate validation.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}