Behavior Ranking & Selection

TLDR: Not all behaviors are equal. Behavior ranking systematically evaluates potential target behaviors on impact, feasibility, and strategic alignment to identify the highest-leverage behaviors for intervention.

Overview #

After identifying potential behaviors through behavioral research, compare which behaviors to target. Selection shapes what the solution must enable, but does not by itself determine success.

Poor selection is a plausible source of failure to investigate. The evidence presented here does not rank it as the leading cause of intervention failure.

Illustrative public-sector scenario, not an observed program result: For SNAP recertification, candidates might include “Start renewal 15 days before deadline,” “Upload required documents in a single session,” and “Attend assistance clinic.” A team might prioritize single-session upload for testing if it has a direct path to completion and fewer apparent context barriers. The ratings would organize that decision; observed attempts would still be needed to establish feasibility.

The Behavior Selection Framework #

Core Evaluation Criteria #

Compare expected impact, provisional fit, and strategic alignment. The optional composite below illustrates one way to summarize judgments; it is not a validated ranking model. Numeric scales and weights need a documented rationale, and the three BFA dimensions must remain visible alongside any summary score.

Illustrative composite = (impact × provisional fit summary × alignment)^(1/3)

The Behavior Fit Assessment is a practitioner decision tool for comparing candidate behaviors across Dispositional Fit, Capability Fit, and Context Fit. It is not a validated measurement instrument. Treat the minimum dimension as a bottleneck and prioritization heuristic; it is not a deterministic probability of behavior.

A score of 6 out of 10 on each Behavior Fit Assessment dimension is a starting threshold that must be calibrated by domain, population, context, stakes, and observed behavior.

Guardrail: Do not over-optimize proxy scores. Audit whether higher ranked behaviors still causally resolve the validated problem.

1. Impact Assessment #

Question: If users perform this behavior, how much value is created?

Illustrative sub-factors: The weights, dollar bands, and rating anchors below are examples to adapt to the outcome; they are not empirical defaults.

impact_factors:
  problem_resolution:
    weight: 0.4
    question: "How completely does this behavior solve the validated problem?"
    scoring:
      0-3: "Minimal problem resolution"
      4-6: "Partial problem resolution"
      7-10: "Complete problem resolution"
  
  value_creation:
    weight: 0.3
    question: "What's the economic/social value per behavior instance?"
    scoring:
      0-3: "Low value (<$10 or minor benefit)"
      4-6: "Moderate value ($10-100 or significant benefit)"
      7-10: "High value (>$100 or transformative benefit)"
  
  network_effects:
    weight: 0.2
    question: "Does this behavior influence others to act?"
    scoring:
      0-3: "Individual only"
      4-6: "Influences 1-2 others"
      7-10: "Influences many others"
  
  sustainability:
    weight: 0.1
    question: "Does impact persist after behavior stops?"
    scoring:
      0-3: "Impact ends immediately"
      4-6: "Impact lasts days/weeks"
      7-10: "Impact lasts months/years"

2. Feasibility Analysis #

Question: Can target users realistically perform this behavior?

BFA comparison: Record a provisional 1-10 rating, its evidence, and the next test for each dimension.

Use the lowest rating to identify a candidate bottleneck. A below-screen rating does not automatically cap a score, reject a candidate, or establish infeasibility. Compare evidence and trial results before selecting. Use the Behavior Fit Assessment for the full construct definitions and the Behavioral State Model for deeper diagnosis; BSM has eight components and is not this three-dimension rating tool.

3. Strategic Alignment #

Question: Does this behavior advance our strategic objectives?

Alignment Matrix:

| Strategic Objective | Behavior Contribution | Score |
|-------------------|---------------------|--------|
| User Acquisition | New users attracted by behavior | 0-10 |
| User Retention | Behavior creates stickiness | 0-10 |
| Revenue Generation | Direct monetization potential | 0-10 |
| Brand Building | Behavior enhances brand | 0-10 |
| Competitive Advantage | Unique/defensible behavior | 0-10 |

The Ranking Process #

Step 1: Behavior Inventory #

Create a list of candidate behaviors. The adoption rates and effort estimates below are illustrative, not measured results:

behavior_inventory:
  - behavior_1:
      name: "Daily progress tracking"
      description: "User logs progress once per day"
      current_adoption: "12% do this naturally"
      required_effort: "2 minutes/day"
      
  - behavior_2:
      name: "Weekly planning session"
      description: "User plans upcoming week"
      current_adoption: "5% do this naturally"
      required_effort: "30 minutes/week"
      
  - behavior_3:
      name: "Share achievement"
      description: "User shares success with network"
      current_adoption: "22% do this naturally"
      required_effort: "1 minute per achievement"

Step 2: Multi-Criteria Scoring #

Score each behavior consistently with your documented rubric. This pseudocode illustrates an optional composite and leaves the assessment methods unspecified. Its feasibility field is a provisional summary judgment, not a BSM score or measured probability; retain the separate BFA ratings and evidence in the decision record. The class is not a ready-to-run scoring tool.

class BehaviorRanker:
    def __init__(self, strategic_weights=None):
        self.strategic_weights = strategic_weights or {
            'acquisition': 0.3,
            'retention': 0.4,
            'revenue': 0.2,
            'brand': 0.1
        }
    
    def rank_behaviors(self, behaviors, user_segment):
        """
        Rank behaviors by combined score
        """
        scored_behaviors = []
        
        for behavior in behaviors:
            # Calculate three core dimensions
            impact = self.calculate_impact(behavior)
            feasibility = self.calculate_feasibility(behavior, user_segment)
            alignment = self.calculate_alignment(behavior, self.strategic_weights)
            
            # Combined score (geometric mean)
            combined_score = (impact * feasibility * alignment) ** (1/3)
            
            # Confidence based on data quality
            confidence = self.assess_confidence(behavior)
            
            scored_behaviors.append({
                'behavior': behavior,
                'scores': {
                    'impact': impact,
                    'feasibility': feasibility,
                    'alignment': alignment,
                    'combined': combined_score
                },
                'confidence': confidence,
                'rank': None  # Set after sorting
            })
        
        # Sort by combined score
        scored_behaviors.sort(key=lambda x: x['scores']['combined'], reverse=True)
        
        # Assign ranks
        for i, sb in enumerate(scored_behaviors):
            sb['rank'] = i + 1
        
        return scored_behaviors

Legacy Criteria Crosswalk (Overview Article) #

For teams familiar with the original article rubric, the legacy criteria map into the framework above as follows:

The legacy checklist can prompt useful questions, but these are conceptual connections, not validated score conversions. It does not replace the current three BFA dimensions or establish scoring reliability.

Step 3: Sensitivity Analysis #

Test how rankings respond to changed assumptions. The simulation below uses an arbitrary normal-noise assumption; its outputs describe that simulation, not real-world confidence or the probability of behavior success.

# Runnable example
import numpy as np
from collections import defaultdict
import copy
rng = np.random.default_rng(42)

def add_measurement_noise(behaviors, std=0.5):
    noisy = copy.deepcopy(behaviors)
    for b in noisy:
        for k in ['impact','feasibility','alignment']:
            b[k] = max(0, min(10, b[k] + rng.normal(0, std)))
    return noisy

def rank_behaviors(behaviors):
    out = []
    for b in behaviors:
        combined = (b['impact'] * b['feasibility'] * b['alignment']) ** (1/3)
        out.append({**b, 'combined': combined})
    out.sort(key=lambda x: x['combined'], reverse=True)
    for i, b in enumerate(out): b['rank'] = i+1
    return out

def sensitivity_analysis(behaviors, variations=100):
    """
    Monte Carlo simulation of ranking stability
    """
    rank_distributions = defaultdict(list)
    for _ in range(variations):
        noisy_behaviors = add_measurement_noise(behaviors, std=0.5)
        rankings = rank_behaviors(noisy_behaviors)
        for behavior in rankings:
            rank_distributions[behavior['name']].append(behavior['rank'])
    stability_report = {}
    for behavior, ranks in rank_distributions.items():
        stability_report[behavior] = {
            'mean_rank': float(np.mean(ranks)),
            'rank_std': float(np.std(ranks)),
            'rank_range': (min(ranks), max(ranks)),
            'top_3_simulation_share': sum(r <= 3 for r in ranks) / len(ranks)
        }
    return stability_report

Step 4: Behavioral Dependencies #

Consider behavior chains and prerequisites:

graph TD
    A[Account Creation] -->|Enables| B[Profile Completion]
    B -->|Enables| C[First Post]
    C -->|Enables| D[Community Engagement]
    D -->|Enables| E[Sustained Behavior]
    
    A -.->|Also Enables| C
    B -.->|Influences| D

Dependency Analysis:

def analyze_dependencies(behaviors):
    """
    Identify behavioral prerequisites and sequences
    """
    dependency_graph = {}
    
    for behavior in behaviors:
        dependencies = {
            'hard_prerequisites': [],  # Must happen first
            'soft_prerequisites': [],  # Helpful but not required
            'enables': [],            # This behavior enables others
            'reinforces': []          # Mutual reinforcement
        }
        
        # Example logic
        if behavior['name'] == 'daily_tracking':
            dependencies['hard_prerequisites'] = ['account_setup', 'initial_goal']
            dependencies['enables'] = ['weekly_review', 'streak_building']
            dependencies['reinforces'] = ['motivation_maintenance']
        
        dependency_graph[behavior['name']] = dependencies
    
    return optimize_behavior_sequence(dependency_graph)

Selection Decision Matrix #

The 2x2 Prioritization Grid #

High Impact ┃ Investigate Fit  │ Priority Candidates
           ┃ (Test barriers)  │ (Validate first)
           ┃                  │
           ┣━━━━━━━━━━━━━━━━━┿━━━━━━━━━━━━━━━━━━━
           ┃ Questionable     │ Stepping Stones
Low Impact ┃ (Usually skip)   │ (Do if enables priority)
           ┃                  │
           ┗━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━━
             Low Feasibility    High Feasibility

Selection Rules #

1. Always Start with One: Focus beats dilution
2. Compare Fit with Impact: A high provisional rating does not replace outcome evidence or a realistic trial
3. Address Dependencies: Enable before requiring
4. Test Assumptions: Pilot before full rollout
5. Monitor Cannibalization: Don’t compete with yourself

Advanced Selection Techniques #

Machine Learning Prediction #

This is an illustrative training snippet, not a validated prediction method or evidence that a suitable dataset exists. It requires comparable observed outcomes, held-out evaluation, and checks for leakage and population drift before use in a decision. Training fit and feature importance do not establish causal effects.

import pandas as pd  # required for the example below
from sklearn.ensemble import RandomForestRegressor

def ml_behavior_prediction(historical_data):
    """
    Use ML to predict behavior success
    """
    # Features: behavior characteristics
    features = historical_data[[
        'complexity_score',
        'time_requirement',
        'social_component',
        'immediate_reward',
        'ability_requirement',
        'motivation_type'
    ]]
    
    # Target: actual adoption rate
    target = historical_data['adoption_success']
    
    # Train model
    model = RandomForestRegressor(n_estimators=100)
    model.fit(features, target)
    
    # Feature importance
    importance = pd.DataFrame({
        'feature': features.columns,
        'importance': model.feature_importances_
    }).sort_values('importance', ascending=False)
    
    return model, importance

Portfolio Optimization #

The illustrative optimization below assumes impact and fit can be multiplied and added across behaviors. Those assumptions and the example’s 5% display cutoff are not validated defaults. The snippet uses fixed constraints; it does not model dependencies, cannibalization, or uncertain effects and cannot establish an optimal real-world portfolio.

from scipy.optimize import minimize

def optimize_behavior_portfolio(behaviors, constraints=None):
    """
    Select optimal mix of behaviors given constraints
    """
    n_behaviors = len(behaviors)
    
    # Objective: maximize total impact
    def objective(weights):
        total_impact = sum(
            w * b['impact'] * b['feasibility'] 
            for w, b in zip(weights, behaviors)
        )
        return -total_impact  # Minimize negative
    
    # Constraints
    cons = [
        {'type': 'eq', 'fun': lambda w: sum(w) - 1},  # Weights sum to 1
        {'type': 'ineq', 'fun': lambda w: w}          # Non-negative
    ]
    
    # Bounds
    bounds = [(0, 1) for _ in range(n_behaviors)]
    
    # Initial guess
    initial = [1/n_behaviors] * n_behaviors
    
    # Optimize
    result = minimize(objective, initial, method='SLSQP', 
                      bounds=bounds, constraints=cons)
    
    # Return portfolio
    portfolio = [
        {'behavior': b, 'allocation': w}
        for b, w in zip(behaviors, result.x)
        if w > 0.05  # 5% threshold
    ]
    
    return sorted(portfolio, key=lambda x: x['allocation'], reverse=True)

Common Selection Mistakes #

Mistake 1: Complexity Bias #

Wrong: Choose the most sophisticated behavior Right: Choose the simplest behavior that solves the problem

Mistake 2: Ignoring Prerequisites #

Wrong: Jump to ideal end-state behavior Right: Build stepping stones to target behavior

Mistake 3: Perfect Information Paralysis #

Wrong: Wait for complete data before selecting Right: Make best guess, test quickly, iterate

Mistake 4: Kitchen Sink Approach #

Wrong: Target many behaviors simultaneously Right: Master one behavior before adding more

Behavior Selection Checklist #

Before finalizing selection, verify:

• Problem-Behavior Fit: Does this behavior actually solve the validated problem?
• User Capability: Do observed attempts support the pre-registered completion criterion for the target population and required support?
• Measurement Plan: Can we reliably measure if behavior occurs?
• Intervention Ideas: Do we have 3+ ways to enable this behavior?
• Failure Recovery: If this behavior fails, what’s Plan B?
• Ethical Screen: Behavior promotes user welfare and avoids coercion
• Competitive Analysis: Are others already “owning” this behavior?

Templates and Tools #

Behavior Ranking Spreadsheet Template #

All values below are illustrative composite judgments. Keep the separate BFA ratings, evidence gaps, and trial results with the sheet. A rank is a starting point for review, not a feasibility verdict.

Decision Documentation Example #

This is a fictional decision memo. Its scores and cohort rationale are examples, not observed findings.

## Behavior Selection Decision

**Date**: January 15, 2026
**Selected Behavior**: Daily check-in
**Decision Makers**: Product Lead, Research Lead, Behavioral Strategy

### Rationale
- Impact Score: 7/10 because daily check-ins predict week-4 retention in prior cohorts.
- Feasibility Score: 9/10 because the action takes under a minute and fits existing routines.  
- Alignment Score: 8/10 because it reinforces the core value proposition.

### Alternatives Considered
1. Weekly Planning - Rejected because setup time is high for new users.
2. Peer Sharing - Rejected because it depends on network effects we don’t yet have.

### Success Criteria
- Adoption target: steady adoption within the first week of onboarding.
- Frequency target: at least three check-ins per week per active user.
- Quality target: check-ins include the required context fields.

### Risk Mitigation
- Risk: novelty-driven check-ins fade after week 2 → Mitigation: rotate prompts and reduce friction in the flow.

Next Steps #

• Apply ranking to your behavioral research findings
• Use selection to guide solution design
• Track selected behaviors with measurement frameworks
• Review case studies of successful behavior selection

Frequently asked questions #

What is behavior ranking? #

Behavior ranking is a structured way to compare candidate behaviors before you build. It scores each behavior on impact, feasibility (for a real population in real context), and strategic alignment.

How is ranking different from choosing a target behavior? #

Ranking is the comparison method. Choosing the target behavior is the decision. Behavioral Strategy makes that decision explicit and evidence-based before solution design.

What is the most common mistake? #

Ranking proxy behaviors (clicks, opens, intent) instead of the behavior that causally produces the outcome. If the top-ranked behavior is not causal, you optimized the wrong thing.

What if all candidate behaviors score poorly on fit? #

Treat low ratings as candidate bottlenecks or evidence gaps. Generate alternatives, investigate constraints, and test the strongest candidates in realistic conditions. BFA ratings alone cannot establish that a behavior is infeasible.

How do I handle dependencies in behavior chains? #

Rank the whole chain rather than a single step. If a prerequisite step is infeasible, the downstream behavior will not scale; enable the weakest step first.

Licensing #

Content © Jason Hreha. Text licensed under CC BY-NC-SA 4.0 unless a more specific asset notice applies. Framework names may be used accurately without implying endorsement.

← Back to Methodology