Trading algoritmico in Python: pipeline completa con dati di mercato, segnali momentum e paper trading

Costruire un sistema di trading algoritmico “da zero” non è (solo) scrivere una strategia. È mettere in piedi una pipeline completa che collega dati, logica, segnali, portafogli ed esecuzione, con attenzione a sicurezza e ripetibilità.

Qui descrivo un’impostazione end‑to‑end in Python che:

1. recupera dati di mercato tramite Massive,
2. calcola un punteggio di momentum a 12 mesi su un universo di 50 azioni,
3. genera segnali di acquisto/vendita in modo automatico,
4. collega e gestisce un portafoglio tramite SnapTrade,
5. esegue gli ordini su Alpaca in modalità paper trading (quindi senza capitale reale).

L’obiettivo non è solo “fare trading”, ma creare un flusso robusto e verificabile, che puoi iterare e migliorare senza cambiare architettura ogni volta.

---

Perché una pipeline (e non uno script)

Uno script che calcola un indicatore e stampa “BUY” è utile per sperimentare. Ma non basta quando devi:

• aggiornare periodicamente i dati,
• mantenere una vista storica (o almeno coerente) dei punteggi,
• tracciare cosa è stato segnalato e quando,
• collegarti a un broker senza gestire credenziali in modo fragile,
• verificare che gli ordini siano arrivati ed eseguiti.

Pensarla come pipeline ti costringe a separare responsabilità e a rendere ogni passaggio osservabile:

Dati → Punteggi → Segnali → Portafoglio → Ordini → Verifica

---

I tre blocchi esterni: Massive, SnapTrade, Alpaca

Massive: il livello “Market Data”

Massive è la fonte dati. In una pipeline come questa, serve soprattutto una cosa: una API key da usare per interrogare prezzi/storici.

Dal punto di vista progettuale è importante ricordare che:

• i piani gratuiti spesso non includono dati real‑time;
• questo influenza le scelte di esecuzione (ad es. dimensionamento semplice e ordini a notional).

SnapTrade: il livello “Connessione sicura al broker”

SnapTrade è lo strato di integrazione che ti consente di collegare l’applicazione a un account broker (qui: Alpaca) tramite un flusso di autorizzazione.

Aspetti pratici che contano in un progetto reale:

• 2FA obbligatoria: prima di generare e usare chiavi API conviene impostarla subito.
• Consumer ID/Key: trattali come segreti. Se li perdi, spesso non sono più visibili.

In architettura, SnapTrade è ciò che evita di trasformare la tua app in un contenitore di password e token gestiti male.

Alpaca: il livello “Broker ed esecuzione” (paper trading)

Alpaca fornisce un conto di paper trading: ti permette di testare strategia e integrazione senza rischi.

Dettagli utili per chi implementa:

• l’account paper parte tipicamente con un saldo simulato (es. 100.000$), ideale per test end‑to‑end;
• l’interfaccia mostra ordini, posizioni, attività e ti aiuta a verificare che la tua pipeline funzioni davvero.

---

Strategia: momentum a 12 mesi su un universo di 50 titoli

Il cuore logico del sistema è semplice e replicabile.

1. Definisci un universo (qui: 50 azioni hardcoded).
2. Per ogni titolo calcoli la performance a 12 mesi (price return).
3. Ordini i titoli per punteggio.
4. Prendi decisioni operative, ad esempio:
   • long sui migliori 10 (top 10),
   • opzionalmente short sui peggiori 10 (bottom 10), se la tua infrastruttura e il tuo broker lo supportano.

In una dashboard “da prodotto” questa logica si presta bene a:

• tabella Top 10 e Bottom 10,
• statistiche sintetiche come media e mediana del momentum,
• pagina “Momentum scores” con ranking completo e highlight (verde/rosso).

Nota operativa: il punteggio spesso è rappresentato come numero decimale (0,985) ma è più leggibile anche come percentuale (+98,5%).

---

Generazione segnali: dal ranking alle azioni

Una volta calcolati i punteggi, serve trasformarli in istruzioni eseguibili.

Un’impostazione pratica e compatibile con dati non real‑time è:

• generare segnali di acquisto per i top 10;
• usare una logica di sizing semplice e deterministica (ad es. importo uguale per ogni titolo).

Esempio: invece di pesare di più il titolo #1 rispetto al #10 (che richiede prezzi aggiornati e più calcoli), investi 100$ per ciascun titolo in top 10.

Questo produce segnali del tipo:

• BUY $100 di WMT
• BUY $100 di NVDA
• …

Il vantaggio è doppio:

• il sistema è più stabile con dati “non perfetti”;
• la verifica è immediata (ogni ordine ha lo stesso notional).

---

Portafogli: il punto in cui molti progetti si rompono

Molti prototipi saltano il concetto di portafoglio: calcolano segnali e basta. Ma appena vuoi eseguire, devi sapere:

• su quale account,
• con quali vincoli (capitale disponibile, frazionabilità, shorting, ecc.),
• con quale strategia dichiarata (utile per audit e tracciabilità).

Un approccio ordinato è gestire i portafogli come entità applicative:

• nome (es. “Momentum Portfolio 2026”),
• strategia (es. “long top 10 momentum”),
• connessione broker via SnapTrade.

Finché non esiste un portafoglio attivo, la generazione segnali può anche essere consentita, ma l’esecuzione deve fallire esplicitamente (meglio un errore chiaro che un comportamento ambiguo).

---

Esecuzione ordini in paper trading: come verificare che tutto funzioni

Quando mandi un ordine, non considerarlo “fatto” finché non lo vedi nel broker.

Flusso consigliato:

1. l’app invia un ordine (es. notional 100$ su un titolo),
2. il broker lo registra (ordine ricevuto),
3. tu controlli in UI broker:
   • presenza dell’ordine,
   • parametri (side, notional, tipo),
   • stato (submitted/filled/canceled).

Un dettaglio da non sottovalutare: alcune UI broker mostrano in modo poco evidente gli ordini notional (importo in $ invece che numero di azioni). È normale che non vedi subito “quante azioni”, perché quel numero viene determinato al momento dell’esecuzione al prezzo corrente.

---

UI e pagine “minime” che rendono il progetto usabile

Se trasformi la pipeline in una piccola app (anche interna), una struttura efficace è in 4 sezioni:

1. Dashboard: stato complessivo, metriche base, link alle azioni principali.
2. Momentum scores: ranking completo, pulsante “recalculate”.
3. Trading signals: generazione segnali + azione “buy/execute” per ogni riga.
4. Portfolios: creazione e collegamento account, storico rebalance/azioni.

Il punto chiave non è la grafica: è avere un’interfaccia che renda ispezionabili i passaggi della pipeline.

---

Implicazioni pratiche (frontend e prodotto)

Anche se la logica è in Python, per un frontend engineer ci sono alcune lezioni interessanti:

• Design dei workflow: “ricalcola → genera segnali → esegui → verifica” è un funnel naturale.
• Gestione degli stati: loading, success, error (es. segnali senza portafoglio attivo).
• Sicurezza per default: 2FA, chiavi non ripetibili, segreti da non esporre.
• Osservabilità: log, timestamp, contatori (quanti titoli aggiornati, quanti segnali generati, quanti ordini inviati).

---

Sintesi e chiusura

Un sistema di trading algoritmico credibile non nasce da un indicatore, ma da una pipeline coerente: dati affidabili, regole di selezione riproducibili, portafogli gestiti come entità, integrazione sicura col broker e verifica dell’esecuzione.

Usare Massive per i dati, SnapTrade per collegare in modo sicuro l’account e Alpaca per il paper trading permette di costruire un circuito chiuso e testabile: ricalcoli i punteggi, generi segnali, invii ordini simulati e controlli il risultato. Da lì in poi, ottimizzare la strategia (pesi, filtri, ribilanciamenti, gestione rischio) diventa un problema incrementale — non una riscrittura completa del progetto.