ROA

Real Options Analysis Applied To AI Pilot Projects

Real Options Analysis Calculator

Interactive Jupyter notebook for valuing AI pilots and R&D projects using Real Options Analysis.

What's This?

Your finance team analyzes pilots using traditional NPV. But NPV assumes you commit everything upfront. For pilots with high uncertainty and staged decision-making, there's a better framework: Real Options Analysis.

This notebook shows you:

1. When ROA matters - Projects that look bad traditionally but are valuable with flexibility
2. When to skip it - Low-risk projects where NPV is fine
3. The volatility paradox - Why uncertainty can increase value

Then try your own project with the interactive calculator.

One-Line Setup

git https://github.com/pjdmatts/ROA
cd ROA
uv run jupyter lab

That's it! Open notebooks/real_options_calculator.ipynb and run all cells.

What You Need

• uv (fast Python package manager)

Don't have uv? Install it:

curl -LsSf https://astral.sh/uv/install.sh | sh

Prefer pip?

pip install -r requirements.txt
jupyter lab

What's Included

The Notebook

Interactive tutorial with three scenarios:

• Hidden Gem: Negative traditional NPV, positive Real Options value
• When ROA doesn't matter: Low uncertainty, traditional NPV is fine
• Volatility Paradox: Two identical projects except uncertainty—risky one is worth more

Plus an interactive calculator for your own projects.

Python Library

from src.real_options import calculate_option_value
from src.scenarios import ScenarioLibrary

# Use a pre-built scenario
scenario = ScenarioLibrary.ai_customer_service()

# Calculate option value
result = calculate_option_value(
    initial_investment=scenario.initial_investment,
    follow_on_investment=scenario.follow_on_investment,
    expected_value=scenario.expected_value,
    volatility=scenario.volatility,
    time_to_decision=scenario.time_to_decision
)

print(f"Traditional NPV: ${result.traditional_npv:,.0f}")
print(f"Expanded NPV: ${result.expanded_npv:,.0f}")
print(f"Learning Premium: ${result.learning_premium:,.0f}")

Pre-Built Scenarios

7 real-world examples:

• AI Customer Service Chatbot
• ML Sales Forecasting
• AI Document Processing
• Pharmaceutical R&D
• New Market Entry
• Platform Technology
• Process Automation

Quick Example

uv run python examples/simple_example.py

Output:

Traditional NPV: $200,000 → REJECT (too risky)
Expanded NPV: $235,000 → PROCEED (option value)
Learning Premium: $35,000 (value from flexibility)

The Math (Simplified)

A pilot is like a call option:

• Underlying Asset: Project value if successful
• Strike Price: Investment required to scale
• Premium: Pilot cost
• Volatility: Uncertainty in outcomes
• Time: When you must decide

Key insight: Higher uncertainty increases option value (because you can walk away if things go badly, but capture upside if they go well).

Use Cases

1. Hidden Gem Detection

"Which rejected projects are actually valuable?"

Filter for: Traditional NPV < 0, Expanded NPV > 0

2. Pilot Valuation

"Should we invest $100K in this AI pilot?"

Run both analyses. If learning premium is significant, Real Options changes the decision.

3. Portfolio Planning

"How should we allocate budget across 10 pilots?"

Compare scenarios, understand which pilots have highest option value.

4. Finance Communication

"How do I explain this to my CFO?"

Reframe: "We're buying decision rights, not committing to outcomes."

Dependencies

Core calculations:

• numpy - Numerical operations
• scipy - Black-Scholes model, statistics

Data & visualization:

• pandas - Tables and data manipulation
• matplotlib - Charts
• seaborn - Prettier plots

Interactive notebook:

• jupyterlab - Modern notebook interface
• ipywidgets - Interactive sliders

All managed automatically by uv via pyproject.toml.

File Structure

real-options-analysis/
├── pyproject.toml              # Dependencies & project config
├── notebooks/
│   └── real_options_calculator.ipynb  # Main notebook
├── src/
│   ├── real_options.py         # Core calculations
│   ├── scenarios.py            # Scenario management
│   └── visualization.py        # Charts & plots
├── examples/
│   └── simple_example.py       # Standalone demo
└── test_installation.py        # Verify setup

Advanced Usage

Create Custom Scenarios

from src.scenarios import create_custom_scenario

scenario = create_custom_scenario(
    name="My AI Pilot",
    pilot_cost=150_000,
    scale_up_cost=1_000_000,
    best_case_value=3_000_000,
    base_case_value=1_500_000,
    worst_case_value=500_000,
    time_to_decision=1.5
)

Sensitivity Analysis

from src.real_options import sensitivity_analysis
from src.visualization import plot_sensitivity_analysis

param_values, option_values = sensitivity_analysis(
    initial_investment=100_000,
    follow_on_investment=500_000,
    expected_value=800_000,
    base_volatility=0.40,
    time_to_decision=1.0,
    param_name='volatility'
)

fig = plot_sensitivity_analysis(param_values, option_values, 'volatility', 'My Pilot')

Portfolio Monte Carlo

from src.real_options import monte_carlo_portfolio

pilots = [
    {'name': 'Pilot A', 'initial_investment': 100_000, ...},
    {'name': 'Pilot B', 'initial_investment': 75_000, ...},
]

results = monte_carlo_portfolio(pilots, n_simulations=10000)
print(f"Mean portfolio value: ${results['mean']:,.0f}")
print(f"Probability of positive return: {results['probability_positive']:.1%}")

When to Use Real Options

Use it when:

• High uncertainty (volatility > 40%)
• Staged investment structure (pilot → scale)
• Meaningful flexibility (can abandon or pivot)
• Clear decision points

Skip it when:

• Low uncertainty (volatility < 25%)
• NPV clearly positive or negative
• Must-do project (compliance, infrastructure)
• No real flexibility

Further Reading

Academic Foundations

• Black, F., & Scholes, M. (1973). "The Pricing of Options and Corporate Liabilities"
• Cox, Ross, & Rubinstein (1979). "Option Pricing: A Simplified Approach"
• Trigeorgis & Reuer (2017). "Real Options Theory in Strategic Management"

Practitioner Books

• Copeland & Antikarov (2001). Real Options: A Practitioner's Guide
• Amram & Kulatilaka (1999). Real Options: Managing Strategic Investment

Related Thinking

• Taleb (2012). Antifragile - On optionality and asymmetric payoffs
• Kay & King (2020). Radical Uncertainty - On decision-making under uncertainty

Contributing

Contributions welcome! Areas of interest:

• Additional scenarios (different industries)
• Enhanced visualizations
• Extended models (competitive dynamics, game theory)
• Case studies with real data

License

MIT License - See LICENSE file

Questions?

• Check test_installation.py for troubleshooting
• Review examples/simple_example.py for usage patterns
• Read the notebook for detailed explanations

---

Remember: A pilot isn't a mini-project with mini-ROI. It's an information purchase that creates decision rights. And that has value—even when traditional NPV says it doesn't.