Diversificazione nel SaaS B2B: come usare Ansoff, Monte Carlo e AI per allocare il budget di crescita

Dalla Matrice di Ansoff alla decision analytics: come l’AI riduce il costo dell’esplorazione, trasforma l’incertezza in distribuzioni di probabilità e modifica la logica di allocazione del capitale di crescita.

La Matrice di Ansoff

La Matrice di Ansoff indica dove un’azienda può cercare la crescita, ma non risponde a tre domande decisive per un manager:

1. Quanto capitale conviene allocare a ciascuna opportunità?
2. Quanto è robusta la decisione quando probabilità e valore futuro sono incerti?
3. È meglio scegliere un singolo progetto oppure finanziare un portafoglio di esperimenti?

Questo articolo costruisce un modello quantitativo applicato a un ipotetico SaaS B2B, DataFlow, utilizzando tre livelli di analisi:

• Valore atteso: confronta economicamente quattro strategie di crescita, includendo l’attualizzazione temporale.
• Monte Carlo: trasforma probabilità e valore di mercato da stime puntuali a distribuzioni e misura la probabilità che ciascuna strategia sia la migliore.
• Ottimizzazione del portafoglio: determina quali esperimenti finanziare quando esiste un budget complessivo di [math]€1.000.000[/math].

Il risultato è interessante: nel caso parametrico analizzato, la diversificazione presenta il maggiore valore atteso, pur avendo la probabilità media di successo più bassa.

Ma questa non significa che la diversificazione sia sempre la strategia migliore.

Significa qualcosa di più interessante:

quando il costo dell’esplorazione è basso rispetto al potenziale payoff, può essere economicamente razionale acquistare informazione attraverso piccoli esperimenti prima di impegnare capitale significativo nello scaling.

L’AI può amplificare questo effetto perché riduce il costo e il tempo necessari per costruire, testare e analizzare nuovi concept.

Livello 1 — Il valore atteso

Il primo passo consiste nel calcolare il valore atteso di ogni strategia.

Per una strategia con prototipo [math]C_p[/math], scaling [math]C_s[/math], probabilità di successo [math]p[/math] e valore [math]V[/math]:

[math]\displaystyle EV = pV – C_p – pC_s[/math]

La formula assume che lo scaling venga sostenuto soltanto nel caso in cui l’iniziativa abbia successo.

Per la diversificazione:

[math]\displaystyle EV_D = 0,30(1.500.000) – 70.000 – 0,30(380.000)[/math]

quindi:

[math]\displaystyle EV_D = 450.000 – 70.000 – 114.000[/math]

[math]\boxed{EV_D = 266.000€}[/math]

Questo è il valore atteso nominale.

Se introduciamo un tasso di attualizzazione annuo del 10%, il valore temporale del denaro deve essere considerato.

Il tasso mensile equivalente è:

[math]\displaystyle r_m = (1 + 0,10)^{1/12} – 1[/math]

e il fattore di attualizzazione per [math]t[/math] mesi è:

[math]\displaystyle DF_t = (1 + r_m)^{-t}[/math]

Per la diversificazione, che richiede 18 mesi:

[math]\displaystyle EV_{D,att} = 266.000 \cdot DF_{18}[/math]

ottenendo circa:

[math]\boxed{EV_{D,att} = 230.565€}[/math]

La vera variabile nascosta: il costo dell’esplorazione

Questo è il punto centrale del modello.

Supponiamo di concentrarci sulla diversificazione:

[math]\displaystyle EV = pV – C_p – pC_s[/math]

Raccogliendo [math]p[/math]:

[math]\displaystyle EV = p(V – C_s) – C_p[/math]

L’EV diventa positivo quando:

[math]\displaystyle p(V – C_s) > C_p[/math]

quindi:

[math]\displaystyle p > \frac{C_p}{V – C_s}[/math]

Nel nostro caso:

[math]\displaystyle p^* = \frac{70.000}{1.500.000 – 380.000}[/math]

[math]\boxed{p^* = 6,25\%}[/math]

Quindi, nel modello semplificato, una probabilità di successo superiore al 6,25% rende positivo l’EV nominale della diversificazione.

Non significa che un manager dovrebbe investire automaticamente in qualsiasi progetto con una probabilità superiore al 6,25%.

Significa che, date queste ipotesi, il costo dell’esplorazione è abbastanza basso rispetto al payoff potenziale da rendere economicamente interessante l’esperimento.

Perché l’AI può cambiare questa equazione

Qui emerge il collegamento con l’innovazione AI.

Supponiamo che l’AI permetta di ridurre:

• tempo di sviluppo del MVP;
• costo della prototipazione software;
• costo della ricerca esplorativa;
• tempo necessario per analizzare il feedback;
• costo della sperimentazione;
• tempo necessario per arrivare a una prima evidenza.

Nel modello questo significa principalmente:

[math]\displaystyle C_p \downarrow[/math]

Ma dalla formula del break-even:

[math]\displaystyle p^* = \frac{C_p}{V – C_s}[/math]

segue immediatamente:

[math]\displaystyle C_p \downarrow \quad \Rightarrow \quad p^* \downarrow[/math]

Questo è un risultato strategicamente importante.

Se l’AI riduce il costo dell’esplorazione, diminuisce la probabilità minima necessaria affinché un esperimento abbia valore economico atteso positivo.

In altre parole:

l’AI non rende automaticamente più sicura l’innovazione; può però renderla più economica da esplorare.

Ed è una differenza fondamentale.

Il prototipo non compra soltanto un prodotto: compra informazione

Considerare il prototipo esclusivamente come un costo è riduttivo.

Un esperimento produce informazione.

Prima del test:

[math]\displaystyle P(\text{successo}) = 30\%[/math]

Dopo il test potremmo scoprire che:

• il mercato non è interessato;
• il willingness to pay è insufficiente;
• il prodotto ha alta activation;
• il retention rate è promettente;
• il cost-to-serve è troppo elevato.

L’informazione modifica quindi la decisione successiva.

La logica diventa:

[math]\displaystyle \text{Investimento piccolo} \rightarrow \text{informazione} \rightarrow \text{aggiornamento delle probabilità} \rightarrow \text{decisione}[/math]

Questo è il cuore della logica delle real options.

L’impresa non sta semplicemente acquistando un prodotto.

Sta acquistando il diritto di decidere più avanti se investire ulteriormente.

Livello 2 — Monte Carlo: dall’incertezza puntuale alla distribuzione

Il 30% utilizzato nel modello deterministico è una stima puntuale.

Nella realtà, però, il management potrebbe dire:

“Stimiamo il 30%, ma non siamo molto sicuri di questa stima.”

È un’informazione diversa.

Per rappresentarla utilizziamo una distribuzione Beta.

Per la diversificazione:

[math]\displaystyle p \sim \text{Beta}(3,7)[/math]

La media è:

[math]\displaystyle E[p] = \frac{3}{3 + 7} = 0,30[/math]

La Beta permette quindi di conservare una probabilità media del 30%, ma di rappresentare anche l’incertezza attorno a quella stima.

Analogamente, il valore di mercato viene rappresentato mediante una distribuzione triangolare:

[math]\displaystyle V \sim \text{Triangolare}(800k, 1.500k, 2.200k)[/math]

In questo modo il modello non chiede più:

“Qual è il valore?”

ma:

“Quali valori sono plausibili e con quale probabilità?”

Perché la scelta dei parametri Beta conta

È importante non confondere la media della probabilità con l’incertezza della probabilità.

Per esempio:

[math]\displaystyle \text{Beta}(3,7)[/math]

ha media 30%.

Ma anche altre distribuzioni Beta possono avere media 30%.

Quindi:

[math]\displaystyle E[p] = 30\%[/math]

non determina da sola la distribuzione.

I parametri [math]\alpha[/math] e [math]\beta[/math] incorporano anche il livello di dispersione della nostra conoscenza.

Questo significa che il modello dovrebbe essere accompagnato da un processo di calibrazione delle probabilità, utilizzando quando possibile:

• dati storici;
• benchmark interni;
• tassi di successo di iniziative analoghe;
• evidenze di customer research;
• risultati di esperimenti precedenti.

Le probabilità non dovrebbero essere trattate come numeri “oggettivi” quando sono in realtà giudizi manageriali.

Livello 3 — Dalla scelta singola al portafoglio

A questo punto introduciamo un budget complessivo:

[math]\displaystyle B = 1.000.000€[/math]

Definiamo:

[math]\displaystyle x_i = \begin{cases} 1 & \text{se finanziamo il prototipo} \\ 0 & \text{altrimenti} \end{cases}[/math]

e:

[math]\displaystyle y_i = \begin{cases} 1 & \text{se finanziamo lo scaling} \\ 0 & \text{altrimenti} \end{cases}[/math]

con:

[math]\displaystyle y_i \leq x_i[/math]

Lo scaling può quindi essere attivato soltanto se il progetto è stato precedentemente finanziato.

Il problema diventa:

[math]\displaystyle \max \sum_i \left[ p_i(V_i – C_{s,i})y_i – C_{p,i}x_i \right][/math]

soggetto al vincolo:

[math]\displaystyle \sum_i (C_{p,i}x_i + p_iC_{s,i}y_i) \leq B[/math]

Questo è un problema di Mixed Integer Linear Programming (MILP).

€460.000 non sono €823.000

I quattro prototipi costano complessivamente:

[math]\displaystyle 180 + 90 + 120 + 70 = 460k[/math]

Quindi:

[math]\boxed{460.000€}[/math]

è il capitale necessario per la fase Explore.

Gli ulteriori:

[math]\displaystyle 823 – 460 = 363k[/math]

rappresentano invece lo scaling atteso, calcolato ex ante attraverso le probabilità di successo.

Pertanto:

Explore

[math]\boxed{460k}[/math]

Scaling atteso

[math]\boxed{363k}[/math]

Impegno atteso complessivo

[math]\boxed{823k}[/math]

Questa distinzione è cruciale per interpretare correttamente il modello.

Il MILP non dice di spendere subito €823.000

Questo è un altro punto fondamentale.

Il modello di ottimizzazione è ex ante.

Utilizza le probabilità di successo per stimare il capitale che, in media, sarà necessario allo scaling.

Non significa che il CFO debba trasferire immediatamente €823.000 ai quattro progetti.

Una strategia manageriale più coerente è:

[math]\boxed{ \text{Explore} \rightarrow \text{Validate} \rightarrow \text{Scale} }[/math]

Prima si finanziano gli esperimenti.

Poi si osservano i risultati.

Solo successivamente si sblocca il capitale di scaling.

Il vero modello: Explore → Validate → Scale

La strategia può essere rappresentata così.

Fase 1 — Explore

Investimento:

[math]\displaystyle €460.000[/math]

Obiettivo:

ottenere evidenza.

KPI:

• activation;
• engagement;
• customer interviews;
• willingness to pay;
• early retention;
• cost-to-serve;
• Idea-to-Evidence Time.

Fase 2 — Validate

Il progetto viene sottoposto a un gate.

La domanda non è:

“Ci piace il progetto?”

ma:

“I dati giustificano un ulteriore investimento?”

Possibili decisioni:

[math]\displaystyle GO[/math]

[math]\displaystyle STOP[/math]

[math]\displaystyle ITERATE[/math]

Questa terza possibilità è importante e non dovrebbe essere ignorata.

Fase 3 — Scale

Solo i progetti che superano il gate ricevono capitale significativo.

Il principio diventa:

[math]\displaystyle \text{Capital follows evidence}[/math]

Il capitale segue l’evidenza.

Il budget di scaling è un’opzione, non un obbligo

Questa è probabilmente la lettura strategica più interessante dell’intero modello.

Supponiamo di spendere €70.000 per costruire un prototipo.

Non stiamo necessariamente decidendo oggi di spendere anche €380.000.

Stiamo comprando la possibilità di prendere quella decisione dopo aver osservato i dati.

Questa struttura assomiglia a una real option:

[math]\displaystyle \text{Costo iniziale} \rightarrow \text{informazione} \rightarrow \text{diritto di investire}[/math]

Il valore del progetto non deriva quindi soltanto dal suo payoff potenziale.

Deriva anche dalla flessibilità decisionale.

Perché quattro esperimenti possono essere migliori di una grande scommessa

La logica tradizionale della pianificazione tende a chiedere:

“Quale dei quattro progetti scegliamo?”

La logica sperimentale chiede invece:

“Quanto costa ottenere informazione su tutti e quattro?”

Se i prototipi hanno costi relativamente bassi, il portafoglio permette di:

• mantenere aperte più opzioni;
• raccogliere informazione;
• eliminare rapidamente le iniziative deboli;
• aumentare l’investimento solo sui progetti promettenti;
• ridurre il rischio di una singola previsione sbagliata.

Questa è una forma di diversificazione dell’incertezza, non semplicemente di diversificazione dei prodotti.

 Il vincolo che il modello non vede: la capacità organizzativa

Il MILP considera il capitale finanziario.

Ma un’azienda non dispone soltanto di denaro.

Dispone anche di:

• persone;
• tempo;
• attenzione manageriale;
• capacità tecnica;
• capacità commerciale;
• capacità di execution.

Possiamo quindi immaginare:

[math]\displaystyle \text{Portfolio Capacity} = \min(\text{Capital}, \text{People}, \text{Attention}, \text{Execution})[/math]

Se quattro esperimenti richiedono contemporaneamente il 100% del tempo del CTO, del CMO e del CEO, il portafoglio apparentemente ottimale dal punto di vista finanziario potrebbe diventare subottimale dal punto di vista organizzativo.

Questo suggerisce un’estensione naturale del modello:

[math]\displaystyle \text{MILP finanziario} + \text{vincoli di capacità}[/math]

 Il valore dell’informazione

C’è un’altra componente che il modello semplificato non quantifica esplicitamente:

il valore dell’informazione prodotta dall’esperimento.

In termini concettuali:

[math]\displaystyle \text{Value of Experiment} = \text{Expected Payoff} + \text{Value of Information} – \text{Experiment Cost}[/math]

L’informazione può permettere di:

• evitare uno scaling sbagliato;
• modificare il pricing;
• cambiare il target;
• riposizionare il prodotto;
• correggere il modello di business;
• interrompere un progetto prima che assorba altro capitale.

Quindi il vero valore di un MVP non è soltanto:

“quanto fatturato può generare?”

ma anche:

“quanto ci permette di imparare prima di impegnare capitale?”

Il vero KPI non è soltanto la revenue: Idea-to-Evidence Time

Un’organizzazione orientata alla sperimentazione dovrebbe misurare anche il tempo necessario per trasformare un’ipotesi in evidenza.

Definiamo:

[math]\displaystyle I2E = \text{Time}(\text{idea} \rightarrow \text{evidence})[/math]

L’obiettivo non è necessariamente:

lanciare il prodotto più velocemente.

È:

imparare più velocemente.

Questo cambia radicalmente il ruolo dell’AI.

Se l’AI riduce:

[math]\displaystyle I2E[/math]

e contemporaneamente riduce:

[math]\displaystyle C_p[/math]

l’organizzazione può esplorare più ipotesi con lo stesso capitale.

Cosa succede se la probabilità di successo cambia?

La probabilità del 30% della diversificazione non è un dato di mercato.

È un’ipotesi.

Supponiamo che, dopo una nuova analisi, il management la riduca al 15%.

L’EV diventa:

[math]\displaystyle EV = 0,15(1.500.000) – 70.000 – 0,15(380.000)[/math]

[math]\displaystyle EV = 225.000 – 70.000 – 57.000[/math]

[math]\boxed{EV = 98.000€}[/math]

Il progetto rimane positivo, ma il vantaggio rispetto alle altre strategie diminuisce sensibilmente.

Questo dimostra perché il modello non dovrebbe essere utilizzato come una calcolatrice che restituisce una risposta definitiva.

È uno strumento per fare analisi di sensibilità.

I limiti del modello

Un modello quantitativo è utile anche quando rende esplicite le proprie semplificazioni.

A. Le probabilità sono soggettive

Il 30% della diversificazione è una stima.

Dovrebbe essere calibrata, quando possibile, su:

• dati storici;
• benchmark;
• esperimenti precedenti;
• evidenza di customer discovery.

B. Le strategie non sono necessariamente indipendenti

Il modello tratta le strategie separatamente.

Nella realtà potrebbero esistere:

• risorse condivise;
• sinergie;
• cannibalizzazione;
• correlazioni tra domanda;
• dipendenze tecnologiche.

Se due progetti falliscono insieme, il rischio del portafoglio è superiore a quello stimato da un modello indipendente.

Se invece condividono infrastruttura o distribuzione, potrebbero esistere economie di scala.

C. Il gate non è veramente binario

La realtà non è:

[math]\displaystyle GO/STOP[/math]

ma spesso:

[math]\displaystyle GO/ITERATE/STOP[/math]

L’iterazione ha un costo e richiede tempo.

Un modello più avanzato dovrebbe quindi includere un budget specifico per gli esperimenti successivi.

D. Non viene modellato il costo dell’opportunità

Il capitale destinato a un esperimento non può essere utilizzato contemporaneamente per un’altra iniziativa.

Questo costo opportunità può diventare rilevante quando l’azienda dispone di poche risorse.

E. Il modello non quantifica pienamente il valore dell’informazione

Il prototipo produce conoscenza.

Il modello base la considera soltanto indirettamente.

Una versione più avanzata dovrebbe modellare esplicitamente il valore della flessibilità e dell’informazione.

F. Il modello assume neutralità al rischio

Massimizzare:

[math]\displaystyle E[EV][/math]

equivale a una logica di decisione neutrale al rischio.

Un’impresa con forti vincoli di liquidità potrebbe preferire un progetto con EV inferiore ma varianza molto più bassa.

In quel caso bisogna introdurre una funzione di utilità o vincoli sul downside risk.

Il codice Python completo

Il modello è riproducibile in Python utilizzando:

• NumPy;
• pandas;
• SciPy;
• Matplotlib.

Il codice implementa:

1. calcolo dell’EV deterministico;
2. attualizzazione;
3. break-even;
4. simulazione Monte Carlo;
5. distribuzioni Beta e triangolari;
6. ranking probabilistico;
7. ottimizzazione MILP;
8. confronto delle 16 combinazioni;
9. dashboard;
10. gate di validazione.

"""
===============================================================================
Ansoff 2026 — Decision Analytics per la crescita SaaS B2B
===============================================================================
Modello didattico che combina:
- valore atteso;
- attualizzazione;
- Monte Carlo;
- portfolio optimization;
- stage-gated experimentation.

Librerie:
numpy, pandas, matplotlib, scipy
===============================================================================
"""

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

from scipy.optimize import milp, LinearConstraint, Bounds
from itertools import product


# =============================================================================
# PARAMETRI GLOBALI
# =============================================================================

BUDGET = 1_000_000
R_ANNUO = 0.10
R_MENSILE = (1 + R_ANNUO) ** (1 / 12) - 1

N_SIM = 50_000
SEED = 42


# =============================================================================
# 1. CASO DATAFLOW
# =============================================================================

strategie = pd.DataFrame({
    "strategia": [
        "Penetrazione",
        "Sviluppo prodotto",
        "Sviluppo mercato",
        "Diversificazione"
    ],
    "prototipo": [
        180_000,
        90_000,
        120_000,
        70_000
    ],
    "scaling": [
        0,
        240_000,
        260_000,
        380_000
    ],
    "prob_successo": [
        0.75,
        0.55,
        0.45,
        0.30
    ],
    "valore_successo": [
        400_000,
        800_000,
        900_000,
        1_500_000
    ],
    "tempo_mesi": [
        3,
        9,
        12,
        18
    ]
})


# =============================================================================
# 2. PARAMETRI MONTE CARLO
# =============================================================================

mc_params = {

    "Penetrazione": {
        "beta_a": 7.5,
        "beta_b": 2.5,
        "triang_low": 300_000,
        "triang_mode": 400_000,
        "triang_high": 500_000
    },

    "Sviluppo prodotto": {
        "beta_a": 5.5,
        "beta_b": 4.5,
        "triang_low": 600_000,
        "triang_mode": 800_000,
        "triang_high": 1_000_000
    },

    "Sviluppo mercato": {
        "beta_a": 4.5,
        "beta_b": 5.5,
        "triang_low": 700_000,
        "triang_mode": 900_000,
        "triang_high": 1_100_000
    },

    "Diversificazione": {
        "beta_a": 3.0,
        "beta_b": 7.0,
        "triang_low": 800_000,
        "triang_mode": 1_500_000,
        "triang_high": 2_200_000
    }
}


# =============================================================================
# 3. EV DETERMINISTICO
# =============================================================================

def calcola_ev(df, r_mensile):

    df = df.copy()

    # Costo atteso:
    # prototipo + scaling sostenuto solo in caso di successo
    df["investimento_atteso"] = (
        df["prototipo"]
        + df["prob_successo"] * df["scaling"]
    )

    # EV nominale
    df["EV_nominale"] = (
        df["prob_successo"] * df["valore_successo"]
        - df["investimento_atteso"]
    )

    # Fattore di attualizzazione
    df["fattore_att"] = (
        1 + r_mensile
    ) ** (-df["tempo_mesi"])

    # EV attualizzato
    df["EV_attualizzato"] = (
        df["EV_nominale"]
        * df["fattore_att"]
    )

    # ROI atteso
    df["ROI_atteso"] = (
        df["EV_nominale"]
        / df["investimento_atteso"]
    )

    return df


strategie = calcola_ev(
    strategie,
    R_MENSILE
)


# =============================================================================
# 4. BREAK-EVEN
# =============================================================================

def break_even(Cp, V, Cs):

    return Cp / (V - Cs)


p_star = break_even(
    70_000,
    1_500_000,
    380_000
)

print(
    f"Break-even diversificazione: {p_star:.2%}"
)


# =============================================================================
# 5. MONTE CARLO
# =============================================================================

def simulazione_monte_carlo(
    df,
    mc_params,
    n_sim,
    r_mensile,
    seed=42
):

    rng = np.random.default_rng(seed)

    ev_matrix = np.zeros(
        (n_sim, len(df))
    )

    for i, row in df.iterrows():

        nome = row["strategia"]
        par = mc_params[nome]

        # Probabilità incerta
        p = rng.beta(
            par["beta_a"],
            par["beta_b"],
            n_sim
        )

        # Valore incerto
        v = rng.triangular(
            par["triang_low"],
            par["triang_mode"],
            par["triang_high"],
            n_sim
        )

        # EV nominale
        ev_nom = (
            p * v
            - row["prototipo"]
            - p * row["scaling"]
        )

        # Attualizzazione
        fattore = (
            1 + r_mensile
        ) ** (-row["tempo_mesi"])

        ev_matrix[:, i] = (
            ev_nom * fattore
        )

    return pd.DataFrame(
        ev_matrix,
        columns=df["strategia"]
    )


mc_results = simulazione_monte_carlo(
    strategie,
    mc_params,
    N_SIM,
    R_MENSILE,
    SEED
)


# =============================================================================
# 6. STATISTICHE MONTE CARLO
# =============================================================================

summary = mc_results.describe().T

summary["P(EV > 0)"] = (
    mc_results > 0
).mean()

summary["P(EV <= 0)"] = (
    mc_results <= 0
).mean()


# Strategia migliore in ogni simulazione
best_strategy = (
    mc_results
    .idxmax(axis=1)
)

prob_best = (
    best_strategy
    .value_counts(normalize=True)
    .sort_index()
)

print("\nProbabilità di essere la strategia migliore:")
print(prob_best)


# =============================================================================
# 7. OTTIMIZZAZIONE PORTAFOGLIO
# =============================================================================

def ottimizza_portafoglio(
    Cp,
    Cs,
    p,
    V,
    budget
):

    n = len(Cp)

    # Variabili:
    # x_i = prototipo
    # y_i = scaling

    c = np.zeros(
        2 * n
    )

    # Massimizziamo EV -> minimizziamo -EV
    c[:n] = Cp

    c[n:] = -p * (
        V - Cs
    )

    # Vincolo di budget
    A_budget = np.zeros(
        (1, 2 * n)
    )

    A_budget[0, :n] = Cp
    A_budget[0, n:] = p * Cs

    # y_i <= x_i
    A_gate = np.zeros(
        (n, 2 * n)
    )

    for i in range(n):

        A_gate[i, i] = -1
        A_gate[i, n + i] = 1

    A = np.vstack(
        [A_budget, A_gate]
    )

    ub = np.array(
        [budget] + [0] * n
    )

    result = milp(

        c=c,

        constraints=LinearConstraint(
            A,
            lb=-np.inf,
            ub=ub
        ),

        bounds=Bounds(
            0,
            1
        ),

        integrality=np.ones(
            2 * n
        )
    )

    x = np.rint(
        result.x[:n]
    ).astype(int)

    y = np.rint(
        result.x[n:]
    ).astype(int)

    costo_atteso = (
        np.dot(Cp, x)
        + np.dot(p * Cs, y)
    )

    EV = (
        np.dot(
            p * (V - Cs),
            y
        )
        - np.dot(Cp, x)
    )

    return (
        x,
        y,
        costo_atteso,
        EV,
        result.success
    )


Cp = strategie["prototipo"].values
Cs = strategie["scaling"].values
p = strategie["prob_successo"].values
V = strategie["valore_successo"].values


x_opt, y_opt, costo_atteso, EV_portafoglio, success = (
    ottimizza_portafoglio(
        Cp,
        Cs,
        p,
        V,
        BUDGET
    )
)


print("\nPortafoglio ottimale:")

for i, nome in enumerate(
    strategie["strategia"]
):

    print(
        nome,
        "| prototipo:",
        bool(x_opt[i]),
        "| scaling:",
        bool(y_opt[i])
    )

print(
    f"\nCosto atteso: €{costo_atteso:,.0f}"
)

print(
    f"EV portafoglio: €{EV_portafoglio:,.0f}"
)


# =============================================================================
# 8. TUTTE LE 16 COMBINAZIONI
# =============================================================================

results = []

for mask in product(
    [0, 1],
    repeat=4
):

    x = np.array(mask)

    y = np.zeros(4)

    for i in range(4):

        if (
            x[i] == 1
            and p[i] * (
                V[i] - Cs[i]
            ) > 0
        ):

            y[i] = 1

    costo = (
        np.dot(Cp, x)
        + np.dot(p * Cs, y)
    )

    if costo <= BUDGET:

        EV = (
            np.dot(
                p * (V - Cs),
                y
            )
            - np.dot(Cp, x)
        )

        nomi = [
            strategie["strategia"].iloc[i]
            for i in range(4)
            if x[i] == 1
        ]

        results.append(
            (
                EV,
                costo,
                tuple(x),
                tuple(y),
                nomi
            )
        )


results.sort(
    reverse=True
)


# =============================================================================
# 9. GATE
# =============================================================================

gates = pd.DataFrame({

    "Metrica": [
        "Activation",
        "Retention 30 giorni",
        "Willingness to pay",
        "NPS",
        "Cost-to-serve"
    ],

    "Soglia": [
        "> 40%",
        "> 70%",
        "> €1.000/mese",
        "> 30",
        "Margine target"
    ],

    "Decisione": [
        "SCALE",
        "SCALE",
        "SCALE",
        "SUPPORTING SIGNAL",
        "SCALE"
    ]
})


# =============================================================================
# 10. EXPLORE → VALIDATE → SCALE
# =============================================================================

framework = pd.DataFrame({

    "Fase": [
        "Explore",
        "Validate",
        "Scale"
    ],

    "Budget": [
        "€460.000",
        "Budget gate",
        "Capitale sbloccato"
    ],

    "Obiettivo": [
        "Ottenere evidenza",
        "Decidere GO / STOP / ITERATE",
        "Investire sui progetti validati"
    ],

    "KPI": [
        "I2E, activation, WTP",
        "Gate pass/fail",
        "Revenue, margine, LTV/CAC"
    ]
})


print("\nFramework:")
print(
    framework.to_string(
        index=False
    )
)

Break-even diversificazione: 6.25%

Probabilità di essere la strategia migliore:
Diversificazione     0.43678
Penetrazione         0.05208
Sviluppo mercato     0.17380
Sviluppo prodotto    0.33734
Name: proportion, dtype: float64

Portafoglio ottimale:
Penetrazione | prototipo: True | scaling: True
Sviluppo prodotto | prototipo: True | scaling: True
Sviluppo mercato | prototipo: True | scaling: True
Diversificazione | prototipo: True | scaling: True

Costo atteso: €823,000
EV portafoglio: €772,000

Framework:
    Fase             Budget                       Obiettivo                       KPI
 Explore           €460.000               Ottenere evidenza      I2E, activation, WTP
Validate        Budget gate    Decidere GO / STOP / ITERATE            Gate pass/fail
   Scale Capitale sbloccato Investire sui progetti validati Revenue, margine, LTV/CAC

Il codice è volutamente un modello ex ante: usa probabilità e payoff attesi per confrontare le alternative. La logica stage-gated rappresenta invece la modalità con cui il capitale dovrebbe essere effettivamente rilasciato nel tempo.

Cosa fare lunedì mattina

Se fossi il CEO di DataFlow, non porterei al board la proposta:

“Investiamo tutto nella diversificazione.”

Porterei una proposta diversa.

1. Finanziare la fase Explore

Allocare:

[math]\boxed{460.000€}[/math]

per costruire i quattro prototipi.

2. Definire i gate prima dell’esperimento

Non dopo.

Per ogni progetto bisogna sapere in anticipo:

• quali metriche verranno osservate;
• quali soglie costituiscono un segnale positivo;
• quando il progetto viene fermato;
• quando è necessaria un’iterazione.

3. Separare il capitale Explore dal capitale Scale

I €540.000 rimanenti non dovrebbero essere considerati automaticamente impegnati.

Devono rappresentare una riserva di capitale condizionata all’evidenza.

4. Definire kill criteria

Per esempio:

Se dopo 60 giorni l’iniziativa non raggiunge la soglia X di activation e la WTP rimane inferiore alla soglia Y, il progetto viene fermato o riprogettato.

Questo riduce il rischio di sunk cost fallacy.

5. Misurare Idea-to-Evidence Time

Non soltanto:

• revenue;
• clienti;
• conversion rate.

Ma anche:

[math]\boxed{I2E}[/math]

Quanto tempo serve per trasformare un’ipotesi in evidenza?

 La nuova logica manageriale

La differenza tra il vecchio e il nuovo approccio può essere sintetizzata così.

Approccio tradizionale

[math]\displaystyle \text{Analisi} \rightarrow \text{Business Plan} \rightarrow \text{Grande Investimento} \rightarrow \text{Risultato}[/math]

Approccio decision analytics

[math]\displaystyle \text{Ipotesi} \rightarrow \text{Esperimento} \rightarrow \text{Evidenza} \rightarrow \text{Aggiornamento} \rightarrow \text{Decisione}[/math]

Il secondo approccio non elimina l’incertezza.

La rende progressivamente più costosa o meno costosa da affrontare.

Ed è qui che l’AI può avere un ruolo strategico.

La conclusione: non scegliere meglio, imparare prima

Il risultato del modello non dimostra che la diversificazione sia sempre la strategia migliore.

Dimostra qualcosa di più generale.

Quando:

[math]\displaystyle C_{explore} \ll \text{Potential Payoff}[/math]

diventa interessante mantenere aperte più opzioni.

L’AI può ridurre:

[math]\displaystyle C_{explore}[/math]

e:

[math]\displaystyle I2E[/math]

rendendo economicamente più conveniente esplorare un numero maggiore di ipotesi.

La conseguenza è un cambiamento nella logica di allocazione del capitale.

Non:

“Quale progetto scegliamo?”

ma:

“Quali opzioni possiamo permetterci di esplorare e quanto costa ottenere abbastanza evidenza per decidere?”

La diversificazione, in questo contesto, non è necessariamente una scommessa più audace.

Può essere una strategia di portfolio experimentation.

Il capitale viene distribuito inizialmente per acquistare informazione e viene concentrato successivamente sui progetti che dimostrano di meritare lo scaling.

La formula concettuale diventa:

[math]\boxed{ AI \rightarrow C_{explore}\downarrow \rightarrow p^*\downarrow \rightarrow \text{più opzioni esplorabili} }[/math]

Il modello quantitativo non sostituisce il giudizio manageriale.

Lo struttura.

Dice:

• quanto capitale esporre;
• quali ipotesi confrontare;
• quanto pesa l’incertezza;
• quando un’opportunità diventa economicamente interessante;
• quando fermarsi;
• quando aumentare l’investimento.

E soprattutto introduce un principio semplice ma potente:

Takeaway per il manager

€460.000
Capitale necessario per esplorare tutti e quattro i progetti del caso DataFlow.

6,25%
Probabilità di break-even nominale della diversificazione nelle ipotesi del modello.

€266.000
EV nominale della diversificazione.

€231.000
EV attualizzato della diversificazione.

43,68%
probabilità che, date le distribuzioni assunte per probabilità di successo e valore economico, la diversificazione abbia l’EV più elevato tra le quattro alternative.

€772.000
EV complessivo del portafoglio ottimale nel modello ex ante.

La lezione non è:

“Scegli la diversificazione.”

La lezione è:

“Quando il costo dell’esplorazione è basso, finanzia informazione prima di finanziare scala.”