Domande Colloquio Data Analyst 2026: Guida Completa SQL, Python e Analytics

I colloqui per Data Analyst nel 2026 testano tre aree fondamentali: competenze SQL, manipolazione dati con Python e risoluzione di problemi aziendali. Aziende come Google, Meta e Amazon hanno standardizzato i loro processi di screening tecnico, con SQL window functions e operazioni Pandas presenti in oltre l'80% dei colloqui.

SQL Window Functions: L'argomento più comune nei colloqui

Le window functions appaiono in quasi tutti gli screening tecnici per Data Analyst. A differenza delle funzioni aggregate che comprimono le righe, le window functions eseguono calcoli su un insieme di righe correlate alla riga corrente mantenendo i dati individuali di ogni riga.

Domanda: Calcola lo stipendio di ogni dipendente come percentuale dello stipendio totale del suo dipartimento.

-- employee_salary_percentage.sql
SELECT 
    employee_id,
    department,
    salary,
    -- SUM come window function preserva ogni riga
    ROUND(
        salary * 100.0 / SUM(salary) OVER (PARTITION BY department),
        2
    ) AS pct_of_dept_salary
FROM employees
ORDER BY department, pct_of_dept_salary DESC;

La clausola PARTITION BY crea finestre separate per ogni dipartimento. Lo stipendio di ogni dipendente viene diviso per il totale del suo dipartimento, non per il totale aziendale. Questa distinzione coglie di sorpresa molti candidati che usano invece una subquery o un join.

Domanda: Trova il totale progressivo delle vendite per data, con reset mensile.

-- monthly_running_total.sql
SELECT
    sale_date,
    amount,
    SUM(amount) OVER (
        PARTITION BY DATE_TRUNC('month', sale_date)
        ORDER BY sale_date
        -- Frame predefinito: RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
    ) AS monthly_running_total
FROM sales
ORDER BY sale_date;

I recruiter si aspettano che i candidati conoscano il comportamento predefinito del window frame. Senza una clausola esplicita ROWS o RANGE, il frame si estende dall'inizio della partizione alla riga corrente, producendo un totale progressivo.

CTE e Subquery: Organizzare query complesse

Le Common Table Expressions rendono le query leggibili e manutenibili. I recruiter valutano se i candidati strutturano le query in modo logico piuttosto che scrivere statement monolitici.

Domanda: Trova i clienti che hanno effettuato acquisti in mesi consecutivi.

-- consecutive_month_purchasers.sql
WITH monthly_purchases AS (
    -- Passo 1: Ottieni combinazioni cliente-mese distinte
    SELECT DISTINCT
        customer_id,
        DATE_TRUNC('month', purchase_date) AS purchase_month
    FROM orders
),
with_prev_month AS (
    -- Passo 2: Aggiungi il mese di acquisto precedente per ogni cliente
    SELECT
        customer_id,
        purchase_month,
        LAG(purchase_month) OVER (
            PARTITION BY customer_id 
            ORDER BY purchase_month
        ) AS prev_purchase_month
    FROM monthly_purchases
)
-- Passo 3: Filtra solo i mesi consecutivi
SELECT DISTINCT customer_id
FROM with_prev_month
WHERE purchase_month = prev_purchase_month + INTERVAL '1 month';

Questo pattern combina le CTE con la window function LAG. Suddividere la query in passaggi nominati dimostra il processo di pensiero, che i recruiter apprezzano quanto la risposta corretta.

Python Pandas: Fondamenti della manipolazione dati

Le domande su Pandas testano competenze di pulizia dati, aggregazione e trasformazione. I recruiter presentano dataset disordinati e chiedono ai candidati di estrarre insight.

Domanda: Dato un DataFrame di sessioni utente, calcola la durata media della sessione per segmento utente, escludendo sessioni inferiori a 10 secondi.

# session_analysis.py
import pandas as pd

def analyze_sessions(df: pd.DataFrame) -> pd.DataFrame:
    """Calcola la durata media della sessione per segmento utente.
    
    Args:
        df: DataFrame con colonne [user_id, segment, session_start, session_end]
    
    Returns:
        DataFrame con durata media per segmento
    """
    # Calcola la durata in secondi
    df['duration_seconds'] = (
        df['session_end'] - df['session_start']
    ).dt.total_seconds()
    
    # Filtra sessioni brevi e aggrega
    return (
        df[df['duration_seconds'] >= 10]
        .groupby('segment')
        .agg(
            avg_duration=('duration_seconds', 'mean'),
            session_count=('user_id', 'count')
        )
        .round(2)
        .reset_index()
    )

La risposta dimostra method chaining, gestione datetime e la funzione agg con output nominati. I recruiter verificano che i candidati filtrino prima dell'aggregazione, non dopo, il che altererebbe le medie.

Domanda: Unisci due DataFrame e gestisci appropriatamente i valori mancanti.

# merge_and_clean.py
import pandas as pd
import numpy as np

def merge_user_data(
    users: pd.DataFrame,
    transactions: pd.DataFrame
) -> pd.DataFrame:
    """Unisce dati demografici utenti con storico transazioni.
    
    Gli utenti senza transazioni ottengono total_spent = 0.
    Le transazioni senza dati utente vengono escluse.
    """
    merged = pd.merge(
        users,
        transactions.groupby('user_id')['amount'].sum().reset_index(),
        on='user_id',
        how='left'  # Mantieni tutti gli utenti, anche senza transazioni
    )
    
    # Riempi NaN per utenti senza transazioni
    merged['amount'] = merged['amount'].fillna(0)
    merged.rename(columns={'amount': 'total_spent'}, inplace=True)
    
    return merged

Il parametro how='left' e la gestione esplicita di fillna mostrano attenzione ai casi limite. I candidati che usano how='inner' perdono gli utenti senza transazioni, modificando la popolazione di analisi.

Concetti statistici: Cosa i Data Analyst devono spiegare chiaramente

Le domande statistiche valutano se i candidati possono applicare i concetti a problemi aziendali reali e comunicare i risultati agli stakeholder.

Domanda: Un product manager afferma che il nuovo flusso di checkout ha aumentato la conversione del 5%. Il test è durato una settimana con 10.000 utenti per variante. Questo risultato è statisticamente significativo?

Una risposta completa affronta dimensione del campione, potenza statistica e significatività pratica:

1. Calcolare l'errore standard: Per i tassi di conversione, SE = sqrt(p(1-p)/n). Con una conversione base del 10% e n=10.000, SE è circa 0,003.

2. Calcolare lo z-score: Un aumento relativo del 5% significa che la nuova conversione è 10,5%. La differenza di 0,5 punti percentuali divisa per SE pooled determina la significatività.

3. Considerare la significatività pratica: Anche se p < 0,05, un aumento di 0,5 punti percentuali potrebbe non giustificare il costo di sviluppo del nuovo flusso.

4. Verificare i fattori confondenti: Una settimana cattura i pattern weekend vs. feriali ma potrebbe perdere cicli mensili o effetti stagionali.

I recruiter apprezzano i candidati che mettono in discussione le assunzioni piuttosto che calcolare meccanicamente i p-value.

Domanda: Spiega la differenza tra correlazione e causalità con un esempio aziendale.

Le vendite di gelato e gli annegamenti correlano positivamente. Entrambi aumentano in estate a causa della variabile confondente temperatura. Raccomandare una riduzione della produzione di gelato per prevenire gli annegamenti confonde correlazione e causalità.

Nell'analytics aziendale: spesa pubblicitaria e ricavi spesso correlano, ma la relazione potrebbe riflettere che le aziende aumentano la spesa pubblicitaria quando le proiezioni di ricavo sono già forti, non che la pubblicità guidi i ricavi. Stabilire la causalità richiede esperimenti controllati o tecniche di inferenza causale come difference-in-differences.

Domande sui Business Case: Tradurre problemi in query

Le domande sui case testano la capacità di scomporre problemi aziendali ambigui in passaggi analitici concreti.

Domanda: La retention degli utenti è calata del 15% il mese scorso. Come indagheresti?

Un approccio strutturato:

1. Validare la metrica: Conferma che la definizione di retention corrisponda ai calcoli storici. Verifica problemi nella pipeline dati o cambiamenti nel tracking.

2. Segmentare il calo: Suddividi la retention per coorte utenti, canale di acquisizione, tipo di dispositivo e area geografica. Un calo complessivo del 15% potrebbe essere un calo del 50% in un segmento che maschera stabilità altrove.

3. Identificare il timing: La retention è calata gradualmente o improvvisamente? Un calo improvviso suggerisce un cambiamento di prodotto o un bug. Un declino graduale indica fattori di mercato o competitivi.

4. Correlare con gli eventi: Allinea la timeline con release di prodotto, campagne marketing, lanci dei competitor ed eventi esterni.

5. Formulare ipotesi: Basandosi sui pattern di segmentazione, proponi spiegazioni testabili e identifica i dati necessari per confermare o confutare ciascuna.

-- retention_by_cohort.sql
WITH user_cohorts AS (
    SELECT
        user_id,
        DATE_TRUNC('week', created_at) AS cohort_week
    FROM users
),
weekly_activity AS (
    SELECT
        user_id,
        DATE_TRUNC('week', activity_date) AS activity_week
    FROM user_events
)
SELECT
    c.cohort_week,
    a.activity_week,
    COUNT(DISTINCT a.user_id) AS active_users,
    COUNT(DISTINCT c.user_id) AS cohort_size,
    ROUND(
        COUNT(DISTINCT a.user_id) * 100.0 / COUNT(DISTINCT c.user_id),
        1
    ) AS retention_pct
FROM user_cohorts c
LEFT JOIN weekly_activity a 
    ON c.user_id = a.user_id 
    AND a.activity_week >= c.cohort_week
GROUP BY c.cohort_week, a.activity_week
ORDER BY c.cohort_week, a.activity_week;

Questa query di analisi per coorte produce i dati necessari per il passaggio 2.

Take-Home Assignment: Cosa valutano i recruiter

Molte aziende includono assignment da svolgere a casa della durata di 2-4 ore. I valutatori assegnano punteggi in base a qualità del codice, rigore analitico e comunicazione.

Assignment tipico: Dato un dataset di transazioni e-commerce, identificare i fattori che predicono il churn dei clienti.

Le submission migliori condividono queste caratteristiche:

• Analisi esplorativa prima: Statistiche descrittive, grafici di distribuzione e valutazione dei valori mancanti prima della modellazione
• Feature engineering: Creazione di feature rilevanti come recency, frequency, monetary value (RFM) e indicatori di trend
• Motivazione della scelta del modello: Spiegare perché la regressione logistica o random forest si adatta al problema, non solo eseguire i default
• Approccio di validazione: Usare split basati sul tempo invece di split casuali per evitare data leakage
• Comunicazione chiara: Executive summary all'inizio, dettagli tecnici in appendice, visualizzazioni che supportano le conclusioni

# churn_analysis_structure.py
import pandas as pd
from sklearn.model_selection import TimeSeriesSplit
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import precision_recall_curve, auc

def create_rfm_features(df: pd.DataFrame, analysis_date: str) -> pd.DataFrame:
    """Crea feature Recency, Frequency, Monetary per cliente."""
    analysis_dt = pd.to_datetime(analysis_date)
    
    rfm = df.groupby('customer_id').agg(
        recency=('order_date', lambda x: (analysis_dt - x.max()).days),
        frequency=('order_id', 'nunique'),
        monetary=('order_total', 'sum')
    ).reset_index()
    
    return rfm

def evaluate_with_time_split(
    X: pd.DataFrame, 
    y: pd.Series,
    n_splits: int = 5
) -> list:
    """Valuta il modello usando cross-validation basata sul tempo."""
    tscv = TimeSeriesSplit(n_splits=n_splits)
    scores = []
    
    for train_idx, val_idx in tscv.split(X):
        model = RandomForestClassifier(n_estimators=100, random_state=42)
        model.fit(X.iloc[train_idx], y.iloc[train_idx])
        
        y_pred_proba = model.predict_proba(X.iloc[val_idx])[:, 1]
        precision, recall, _ = precision_recall_curve(y.iloc[val_idx], y_pred_proba)
        scores.append(auc(recall, precision))
    
    return scores

Il codice dimostra feature engineering rilevante per il dominio e metodologia di validazione appropriata per dati time-series.

Punti chiave per i colloqui Data Analyst nel 2026

• Le SQL window functions con PARTITION BY e ORDER BY appaiono nella maggior parte degli screening tecnici. Esercitati nel calcolo di totali progressivi, percentuali e ranking.

• Le domande Python Pandas enfatizzano method chaining, aggregazioni groupby e operazioni di merge con corretta gestione dei valori mancanti.

• Le domande statistiche richiedono di spiegare i concetti in termini aziendali. I recruiter valutano la capacità comunicativa, non solo le conoscenze tecniche.

• Le domande sui business case testano la scomposizione strutturata dei problemi. Inizia validando la metrica, poi segmenta per isolare il problema.

• I take-home assignment vengono valutati per qualità del codice e comunicazione tanto quanto per accuratezza analitica. Includi un executive summary e spiega le tue scelte.