Integrations: connecting tools and warehouse

Il binario di questa lezione è quello tabellare: le integrazioni esistono per popolare tabelle confrontabili, con chiavi e regole di riconciliazione esplicite. CRM, advertising, product analytics e billing raccontano lo stesso cliente con chiavi diverse e tempi di aggiornamento diversi. Connettere tool e warehouse significa decidere quale fonte è autorevole, come gestire l’identità e come riconciliare dati che non nascono per stare insieme. Senza queste scelte, CAC e payback restano opinioni.

Il senso delle integrazioni

Le integrazioni portano dati da tool operativi al warehouse con chiavi, tempi e regole di riconciliazione esplicite così che le metriche restino confrontabili. In breve: ogni fonte arriva con il suo contratto.

Il percorso in cinque passi

1. Elenca le fonti con owner, chiave primaria e frequenza di aggiornamento.

2. Scegli per ogni fonte il pattern adatto tra managed, reverse, webhook e script.

3. Definisci chiavi di join, mapping dei campi e gestione di null e duplicati.

4. Dichiara fonte autorevole e tolleranze per ogni metrica riconciliata.

5. Monitora volumi, ritardi ed errori dei connettori con alert e owner.

Quattro pattern operativi

TheETL e l’ELT managed with Fivetran, Airbyte e Stitch vanno dai SaaS via API al warehouse. Offrono centinaia di connettori pre-costruiti e setup in pochi minuti. Sono l’ideale per Salesforce, Stripe e Facebook Ads, con costo tipico intorno a 100-500 dollari al mese per connettore. Il reverse ETL with Hightouch e Census fa il percorso opposto. Riporta segmenti e metriche dal warehouse ai tool operativi. L’approccio webhook plus Lambda serve quando manca un connettore managed: il tool chiama un endpoint, una funzione processa e scrive su coda o storage. Gli script custom in Python with cron restano adatti a fonti interne come Excel, CSV e legacy. Ogni cambio di schema richiede però manutenzione manuale.

Verdetto: managed per tool standard e custom solo dove nessun connettore copre la fonte.

The integration matrix

La tabella fissa metodo, latenza attesa e affidabilità per fonte così il confronto resta esplicito.

Source	Method	Latency	Reliability
Stripe, Salesforce, HubSpot	Fivetran/Airbyte	5-15 min	High
Facebook Ads, Google Ads	Fivetran/Singer	1-6 hours	Medium (API rate limits)
Internal prod database	Debezium CDC	<1 min	High
Google Sheets	Python script + gspread	1 hour	Low
Internal event stream	Kafka → ClickHouse	<1 sec	High

Reference: Fivetran. (2024). “What is Data Integration?” fivetran.com.

Verdetto: latenza dichiarata più fonte autorevole batte sync generico senza tolleranze.

Una vista SQL per verificare le integrazioni

La vista seguente crea una base settimanale per fonte e dispositivo per confrontare periodi e gruppi senza riscrivere la logica.

WITH base_events AS (
  SELECT
    user_id,
    account_id,
    event_type,
    event_time,
    DATE_TRUNC('week', event_time) AS week,
    source,
    device_type
  FROM events
  WHERE event_time >= CURRENT_DATE - INTERVAL '180 days'
    AND user_id IS NOT NULL
),
weekly_user_metrics AS (
  SELECT
    week,
    user_id,
    COALESCE(source, 'unknown') AS source,
    COALESCE(device_type, 'unknown') AS device_type,
    COUNT(*) AS total_events,
    COUNT(DISTINCT DATE(event_time)) AS active_days,
    COUNT(DISTINCT event_type) AS event_diversity,
    MAX(CASE WHEN event_type IN ('purchase', 'subscribe', 'activation') THEN 1 ELSE 0 END) AS reached_key_outcome
  FROM base_events
  GROUP BY week, user_id, source, device_type
)
SELECT
  week,
  source,
  device_type,
  COUNT(DISTINCT user_id) AS users,
  ROUND(AVG(active_days), 2) AS avg_active_days,
  ROUND(AVG(event_diversity), 2) AS avg_event_diversity,
  ROUND(AVG(reached_key_outcome) * 100, 2) AS key_outcome_rate
FROM weekly_user_metrics
GROUP BY week, source, device_type
ORDER BY week, source, device_type;

Usala dopo ogni nuova integrazione per verificare che i volumi riconciliati non rompano trend e segmenti.

Un controllo Python di stabilità

Una metrica integrata deve restare stabile per decidere e sensibile per segnalare rotture di sync.

# df contiene: week, segment, users, key_outcome_rate
# key_outcome_rate espresso in percentuale, es. 12.4

df = df.sort_values(['segment', 'week']).copy()
df['previous_rate'] = df.groupby('segment')['key_outcome_rate'].shift(1)
df['wow_change_pp'] = df['key_outcome_rate'] - df['previous_rate']
df['rolling_mean'] = df.groupby('segment')['key_outcome_rate'].transform(
    lambda s: s.rolling(4, min_periods=2).mean()
)
df['rolling_std'] = df.groupby('segment')['key_outcome_rate'].transform(
    lambda s: s.rolling(4, min_periods=2).std()
)
df['z_score'] = (df['key_outcome_rate'] - df['rolling_mean']) / df['rolling_std']

anomalies = df[df['z_score'].abs() >= 2].sort_values('z_score')
print(anomalies[['week', 'segment', 'key_outcome_rate', 'wow_change_pp', 'z_score']])

Un’anomalia dopo un deploy di connettore punta quasi sempre all’integrazione, non al mercato.

Typical mistakes

Il primo errore è aggregare troppo presto e nascondere segmenti opposti. Il secondo è ignorare finestre temporali, chiavi account, valute, rimborsi e lag di sync prima di calcolare CAC e payback. Il terzo è confondere correlazione e causalità. Ogni analisi richiede definizione esplicita, confronto per segmento e verifica su periodo precedente.

Verdetto: chiavi e finestre dichiarate prima del modello battono join improvvisati dopo.

Il caso che mostra il collo di bottiglia

Nel giugno 2019 Google annuncia l’accordo per acquisire Looker per 2,6 miliardi di dollari in contanti, operazione completata nel febbraio 2020. Looker portava la modellazione semantica sopra il warehouse e Google portava BigQuery e la distribuzione cloud. Il prezzo mostra dove il mercato vedeva il collo di bottiglia: non in un’altra dashboard ma nell’integrazione governata tra warehouse e consumo. Chi disegna connettori e modelli condivisi lavora esattamente su quel collo di bottiglia.

[SQL]Try it yourself

Write a query that finds the most expensive order for each product category (Sports, Apparel, Electronics). Show category, product, and amount.

RunCtrl+Enter to runHintSolution

Controlla di aver capito

1. Quale pattern scegli per Salesforce rispetto a un CSV interno?

2. Quali chiavi e tolleranze dichiari prima di riconciliare due fonti?

3. Come distingui una rottura di sync da un fenomeno reale?

4. Quale fonte fa fede quando CRM e warehouse divergono?