Analisi di coorte e behavioral cohorts

Le nuove iscrizioni crescono, ma alcune coorti restano attive dopo una settimana mentre altre spariscono subito. L’analisi di coorte e le behavioral cohorts servono a separare la data di ingresso, il comportamento iniziale e il valore nel tempo, così non leggi la crescita come un segnale di salute del prodotto senza prove concrete.

Una scena da cui partire

Immagina la riunione di fine trimestre. Il grafico delle iscrizioni sale, qualcuno propone un brindisi, ma nessuno sa dire quanti di quegli utenti useranno ancora il prodotto fra un mese. È il momento in cui le coorti diventano utili, perché rivelano quali comportamenti iniziali anticipano retention, espansione o abbandono. La domanda da tenere in testa non è quanti utenti sono entrati, ma cosa hanno fatto nei primi giorni e dove sono finiti.

Perché la segmentazione demografica non basta

Segmentare per demografia assume che persone simili si comportino in modo simile, ma nel digitale questa ipotesi spesso fallisce. Prendi tre utenti di un’app fitness.

Marco ha 28 anni, vive a Milano e usa Android: corre 5 km ogni mattina, traccia il percorso con l’app e attiva il premium dopo 3 giorni. Giulia ha gli stessi dati anagrafici di Marco, ma apre l’app due volte, non completa allenamenti e sparisce dopo una settimana. Ahmed ha 52 anni, vive al Cairo e usa il browser web: corre 8 km a giorni alterni, consulta l’app per le statistiche settimanali e passa al premium dopo 10 giorni.

Marco e Giulia sono demograficamente identici, ma comportamentalmente Marco e Ahmed sono molto più vicini. Segmentare solo per anagrafica mescola power user e dormant nello stesso gruppo, e quello che ottieni è rumore.

Approccio	Variabile di raggruppamento	Esempio	Risposta
Demografico	Chi è l’utente	Età, paese, device	”Gli utenti iOS spendono più di Android?”
Comportamentale	Cosa fa l’utente	Frequenza, feature usate	”I power user hanno un LTV 3x?”
Coorte temporale	Quando ha iniziato	Mese di iscrizione	”La retention migliora nel tempo?”

La behavioral cohort risponde alla domanda che conta davvero: come si comportano gli utenti e come evolvono nel tempo?

Coorti temporali e coorti comportamentali

L’analisi di coorte classica raggruppa gli utenti per settimana di acquisizione e misura la retention nel tempo.

SELECT
  DATE_TRUNC('week', signup_date) AS cohort_week,
  COUNT(DISTINCT user_id) AS cohort_size,
  ROUND(COUNT(DISTINCT CASE WHEN week_1_active THEN user_id END) * 100.0 / COUNT(*), 1) AS week1_retention,
  ROUND(COUNT(DISTINCT CASE WHEN week_2_active THEN user_id END) * 100.0 / COUNT(*), 1) AS week2_retention,
  ROUND(COUNT(DISTINCT CASE WHEN week_4_active THEN user_id END) * 100.0 / COUNT(*), 1) AS week4_retention,
  ROUND(COUNT(DISTINCT CASE WHEN week_12_active THEN user_id END) * 100.0 / COUNT(*), 1) AS week12_retention
FROM user_cohorts
GROUP BY cohort_week
ORDER BY cohort_week;

Questa analisi dice se la retention migliora con le nuove versioni, ma non spiega perché certi utenti restano e altri se ne vanno. La behavioral cohort raggruppa in base alle azioni compiute, non alla data di iscrizione, e risponde a una domanda diversa: quali pattern definiscono un utente di successo?

Costruire behavioral cohorts in SQL

Conviene segmentare gli utenti su quattro dimensioni. La frequenza misura quanti giorni l’utente è stato attivo negli ultimi 30. L’ampiezza conta quante feature diverse ha usato. La profondità guarda il volume totale di attività. I segnali chiave registrano le azioni critiche come acquisto, invito o creazione di contenuto.

WITH user_behavior_30d AS (
  SELECT
    user_id,
    COUNT(DISTINCT DATE(event_time)) AS active_days,
    COUNT(*) AS total_events,
    COUNT(DISTINCT event_type) AS unique_event_types,
    MAX(CASE WHEN event_type = 'purchase' THEN 1 ELSE 0 END) AS has_purchased,
    MAX(CASE WHEN event_type = 'invite' THEN 1 ELSE 0 END) AS has_invited,
    MAX(CASE WHEN event_type = 'create_project' THEN 1 ELSE 0 END) AS has_created,
    AVG(session_duration_seconds) AS avg_session_secs
  FROM events
  WHERE event_time >= CURRENT_DATE - INTERVAL '30 days'
    AND user_id IS NOT NULL
  GROUP BY user_id
)
SELECT
  user_id,
  CASE
    WHEN active_days >= 20 AND has_purchased = 1 AND has_invited = 1 THEN 'champion'
    WHEN active_days >= 20 THEN 'power_user'
    WHEN active_days >= 10 THEN 'regular'
    WHEN active_days >= 3 THEN 'casual'
    WHEN active_days >= 1 THEN 'dormant'
    ELSE 'dead'
  END AS behavior_segment,
  active_days,
  total_events,
  unique_event_types,
  has_purchased,
  has_invited,
  ROUND(avg_session_secs, 0) AS avg_session_secs
FROM user_behavior_30d;

A ogni segmento corrisponde un’azione di prodotto diversa.

Segmento	Caratteristica	Azione prodotto
Champion	Usa, paga, invita	Nurturing, community
Power User	Quotidiano, tutte le feature	Retention, upsell
Regular	Più volte a settimana	Deepening: scoprire feature
Casual	3-9 giorni/mese	Activation: spingere abitudine
Dormant	1-2 giorni/mese	Re-engagement: notifiche
Dead	Zero attività	Win-back o disinvestimento

Il valore non sta nella fotografia di un singolo mese, ma nel tracciare il movimento degli utenti tra un segmento e l’altro.

La matrice di transizione comportamentale

Gli utenti cambiano: un dormant può diventare regular, un power user può decadere. La matrice di transizione mostra dove vanno gli utenti da un mese all’altro.

WITH current_month AS (
  SELECT user_id, behavior_segment AS current_segment
  FROM user_behavior_monthly
  WHERE month_key = '2025-01'
),
previous_month AS (
  SELECT user_id, behavior_segment AS previous_segment
  FROM user_behavior_monthly
  WHERE month_key = '2024-12'
)
SELECT
  COALESCE(p.previous_segment, 'new') AS from_segment,
  c.current_segment AS to_segment,
  COUNT(*) AS users,
  ROUND(COUNT(*) * 100.0 / SUM(COUNT(*)) OVER (PARTITION BY COALESCE(p.previous_segment, 'new')), 1) AS pct
FROM current_month c
LEFT JOIN previous_month p ON c.user_id = p.user_id
GROUP BY COALESCE(p.previous_segment, 'new'), c.current_segment
ORDER BY from_segment, to_segment;

Tre indicatori meritano attenzione. Il decadimento dei power user è un campanello d’allarme di prodotto se supera il 15% mensile. La resurrezione dei dormant sotto il 5% segnala un re-engagement inefficace. Il passaggio dei casual a regular è invece il motore della crescita di lungo termine, e va alimentato di proposito.

Caso Netflix

Nel 2012 Netflix scoprì che il 22% dei power user diventava regular in 2 mesi perché finivano i contenuti preferiti. La risposta fu la personalizzazione predittiva, che ridusse il decadimento al 9% in 6 mesi, alzando retention e ricavi.

Il behavioral lifecycle framework

Il ciclo di vita comportamentale descrive la traiettoria d’uso di un utente, dall’attivazione fino all’eventuale abbandono.

New User ──activation──▶ Activated ──deepening──▶ Engaged ───power──▶ Power User
                            │                       │                    │
                            ▼                       ▼                    ▼
                         Dormant ◀────decay────────┘                    │
                            │                                            │
                            │              re-engagement                 │
                            └────────────────────────────────────────────┘
                            │
                            ▼
                         Churned (60+ giorni inattivo)

Ogni transizione ha una metrica che la misura e un team che ne risponde.

Transizione	Metrica	Owner	Benchmark B2C
New → Activated	Activation rate	Growth	20-40%
Activated → Engaged	Deepening rate	Feature team	30-50%
Engaged → Power	Power conversion	Core product	10-25%
Qualunque → Dormant	Decay rate	Retention	5-15% mensile
Dormant → Active	Resurrection rate	CRM	3-8% mensile

Il dashboard di prodotto dovrebbe monitorare questi tassi proprio per capire dove si sta perdendo valore.

Behavioral cohorts nel codice: Python per analisi avanzata

Quando non conosci i pattern in anticipo, il clustering non supervisionato aiuta a scoprire i segmenti naturali. Si costruiscono le feature comportamentali (giorni attivi, eventi, tipi di evento, azioni chiave), si standardizzano i valori e si applica K-Means, poi si etichettano i cluster leggendo i centroidi. Il vantaggio è che non imponi segmenti predefiniti: lasci che emergano dai dati e usi il metodo del gomito per scegliere quanti cluster tenere.

Caso reale: behavioral cohorts in Spotify

Spotify ha identificato sei segmenti basati su volume di ascolto, diversità degli artisti, creazione di playlist e attività social. Il segmento più prezioso non era quello con più minuti, ma quello con alta diversità e creazione: utenti che esplorano e curano playlist. Il loro LTV era 2.3x rispetto ai passive listeners. La scoperta ha cambiato l’onboarding, spostando l’obiettivo verso far creare una playlist entro i primi 10 minuti.

Retention per coorte comportamentale

Incrociare le behavioral cohorts con la retention temporale mostra che gli utenti con alto engagement iniziale mantengono una retention da 3 a 5 volte superiore a quelli con basso engagement.

WITH user_first_month_behavior AS (
  SELECT u.user_id,
    COUNT(DISTINCT DATE(e.event_time)) AS first_month_active_days,
    COUNT(DISTINCT e.event_type) AS first_month_event_types
  FROM users u
  JOIN events e ON u.user_id = e.user_id
    AND e.event_time BETWEEN u.signup_date AND u.signup_date + INTERVAL '30 days'
  GROUP BY u.user_id
),
user_monthly_activity AS (
  SELECT u.user_id,
    DATE_TRUNC('month', u.signup_date) AS signup_cohort,
    DATE_TRUNC('month', e.event_time) AS activity_month,
    (DATE_TRUNC('month', e.event_time) - DATE_TRUNC('month', u.signup_date)) / INTERVAL '1 month' AS month_number
  FROM users u
  JOIN events e ON u.user_id = e.user_id
)
SELECT
  CASE
    WHEN f.first_month_active_days >= 20 THEN 'high_engagement'
    WHEN f.first_month_active_days >= 10 THEN 'medium'
    WHEN f.first_month_active_days >= 3 THEN 'low'
    ELSE 'minimal'
  END AS initial_behavior_segment,
  a.month_number,
  COUNT(DISTINCT a.user_id) AS retained_users
FROM user_monthly_activity a
JOIN user_first_month_behavior f ON a.user_id = f.user_id
WHERE a.signup_cohort >= '2024-01-01'
GROUP BY initial_behavior_segment, a.month_number
ORDER BY initial_behavior_segment, a.month_number;

Il messaggio è che la retention si costruisce a monte, nell’onboarding, non dopo.

Quando le behavioral cohorts falliscono

Ci sono tre limiti da tenere presenti. Servono volumi sufficienti di dati comportamentali, almeno 5-10 eventi per utente attivo, altrimenti i segmenti sono fragili. La classificazione è retrospettiva, perché etichetta un utente solo dopo che ha già mostrato il comportamento. E ignora l’intento: due utenti con lo stesso comportamento misurato possono avere motivazioni opposte. Per questo conviene sempre validare con dati qualitativi, dagli NPS alle interviste fino ai ticket di supporto.

Riferimenti e approfondimenti

• Croll & Yoskovitz, Lean Analytics, capitolo 7
• McClure, Pirate Metrics AARRR
• Chen, The Cold Start Problem
• Amplitude, The Behavioral Cohorts Playbook
• Kohavi et al., Trustworthy Online Controlled Experiments, capitolo 5

Riepilogo

Le behavioral cohorts spostano l’analisi da chi è l’utente a cosa fa l’utente. La matrice di transizione mostra dove si perdono o si guadagnano utenti, e il lifecycle framework assegna a ogni transizione una metrica, un target e un responsabile. Combinando coorti temporali e comportamentali capisci se la retention migliora per tutti o solo per chi era già engaged. Nella prossima lezione useremo questi segmenti per personalizzare gli esperimenti A/B e misurarne gli effetti sulle diverse categorie di utenti.