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.

Public-sector example: 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.

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?

Sub-factors: The weights, dollar bands, and rating anchors below are examples. Adapt them to your outcome.

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 made up for the example:

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 snippet shows the idea. It is not a validated prediction method, and it assumes a dataset you may not have. 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 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

The values below are made-up 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

Here is an example decision memo. Its scores are made up.

## 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