Come tradurre e classificare automaticamente le risposte dei moduli con n8n e IA

Nei due articoli precedenti di questa serie abbiamo visto prima perché vale la pena raccogliere feedback dei clienti e poi come creare un modulo di feedback utile per capire cosa accade su un sito web o in un’app subito dopo una conversione.

In questo terzo articolo facciamo un passo in più. Non parliamo più solo di raccogliere risposte, ma di elaborarle. 

Perché analizzare le risposte dei campi aperti di qualsiasi modulo richiede tempo se non viene automatizzato. Soprattutto se arrivano in più lingue.

La serie completa su come raccogliere e usare il feedback dei clienti ha quattro parti:

1. Perché raccogliere feedback dei clienti è indispensabile.
2. Come creare un modulo di feedback utile.
3. Come usare l’IA per tradurre e classificare risposte aperte.
4. Come trasformare quel feedback in dashboard e in una routine mensile di monitoraggio.

Qui ci concentreremo sul terzo punto: montare un workflow con n8n, Google Sheets e Gemini per tradurre, classificare e arricchire risposte aperte dei moduli.

Quale problema risolviamo con questo workflow

Le domande chiuse del modulo sono facili da analizzare. 

Se chiedi di valutare da uno a dieci la facilità del processo (o qualsiasi altra cosa), il motivo principale della decisione, l’età, il paese o se l’utente ha avuto problemi, ogni risposta viene classificata con un valore compreso in un numero limitato di valori.

Il problema nasce con le risposte aperte.

È lì che l’utente spiega con le sue parole cosa gli è successo: che non trovava un’informazione, che il pagamento gli ha creato dubbi, che ha confrontato con un’altra piattaforma dove costava meno, che ha avuto un problema con un coupon nel checkout, che voleva parlare con una persona o che il processo è stato chiaro e rapido.

Questo tipo di commento è molto prezioso, ma ha tre difficoltà:

1. Bisogna leggerlo.
2. Bisogna capire e interpretare il contesto.
3. E, se ci sono più lingue, bisogna tradurlo o normalizzarlo prima di confrontarlo.

Se hai poche risposte, puoi farlo a mano. Se inizi ad avere volume, mercati diversi o commenti in cinque lingue, smette di essere fattibile. 

Nel caso che usiamo come esempio, il modulo era pensato in spagnolo, neerlandese, francese, inglese e tedesco. Per questo aveva senso aggiungere uno strato di IA.

L’idea non è che l’IA decida per il business, ma che prepari il dato: 

1. Tradurre commenti.
2. Classificare problemi.
3. Rilevare menzioni di competitor.
4. Preparare un documento Google Sheets pronto per l’analisi nel passaggio successivo.

Cosa costruiremo

Costruiremo un workflow di n8n che fa quanto segue:

1. Legge un foglio di Google Sheets con risposte dei moduli.
2. Rileva quali risposte sono nuove per non elaborare duplicati.
3. Aggiunge un contesto di categorie perché l’IA classifichi in modo coerente.
4. Invia i campi aperti a un LLM (Gemini, nel nostro caso).
5. Riceve una risposta in JSON.
6. Converte quel JSON in colonne con il formato corretto.
7. Scrive il risultato finale in un altro foglio di Google Sheets con i risultati dell’IA.

Non è una ricetta universale che puoi copiare senza toccare nulla. 

È adattata a un modulo concreto di feedback dei clienti su un sito di prenotazioni, ma la logica si può trasferire a un ecommerce, a un corso, a un sito di servizi o a qualsiasi modulo di feedback su un asset digitale in cui vuoi classificare risposte aperte.

Strumenti che useremo

Per questo flusso usiamo diversi strumenti concreti:

• n8n, come strumento di automazione.
•  Google Sheets, come foglio di ingresso e di uscita.
• Gemini, come modello di IA per tradurre e classificare.
• Data Studio, che sarà la destinazione naturale per visualizzare i dati nell’articolo successivo.

In questo caso usiamo Gemini Flash Lite perché il compito è relativamente leggero: analizzare commenti brevi, scegliere una categoria, rilevare se compare un competitor e restituire un JSON. Non ci serve il modello più potente per questo, ma un modello rapido, economico e stabile.

Nel nostro caso il costo previsto era di appena pochi centesimi al giorno. Abbiamo scelto anche la versione latest di Flash Lite perché fissando versioni precedenti, come 2.0 o 2.5, comparivano problemi di disponibilità. 

E in un flusso automatizzato la stabilità conta quanto, se non più, della qualità.

La temperatura del modello è configurata a 0.1.  

Anche questo è intenzionale: qui non cerchiamo creatività, ma coerenza. 

Vogliamo che risposte simili siano classificate in modo simile e che il modello rispetti il formato JSON che gli chiediamo.

Prima di iniziare: come deve essere preparato il foglio delle risposte

Come ti spiegavo nel post precedente, prima di montare il workflow ci serve un foglio di Google Sheets con le risposte originali del modulo.  

Può arrivare direttamente da Google Forms oppure può essere un foglio in cui abbiamo unificato risposte provenienti da un altro sistema, come un CRM o diversi moduli in varie lingue.

La cosa importante è che il foglio abbia una struttura stabile: una riga per risposta e una colonna per domanda. 

In questo esempio lavoriamo con campi associati alle risposte:

• Record ID (che usiamo per evitare duplicati).
• Data.
• Mercato (sono cinque domini diversi).

E quelli delle risposte vere e proprie:

• Facilità di prenotazione (scala 1-10).
• Motivo della decisione (5 possibilità).
• Se ha avuto problemi e il dettaglio del problema.
• Valutazione del sito web.
• Commento libero.
• Paese (non è la stessa cosa del mercato, perché un finlandese può prenotare sul sito inglese).
• Genere.
• Età.
• E se l’utente si aspetta una risposta.

Non è necessario che il tuo foglio abbia esattamente le stesse colonne. La cosa importante è che ci sia un identificatore univoco per ogni risposta. In questo workflow usiamo Record ID per sapere quali righe sono già state elaborate e quali sono nuove.

Se lavori in più lingue, conviene mantenere la stessa struttura di domande e risposte in tutte, cambiando solo la traduzione. 

Così puoi analizzare dati aggregati e, allo stesso tempo, segmentare per lingua, paese o mercato. Tutto questo lo abbiamo visto nel post precedente su come creare il modulo.

Workflow in n8n passo passo

Il workflow completo resta organizzato in nove nodi principali:

Ogni ora:

 → Leggere Sheets origine.

 → Impacchettare origine.

 → Filtrare nuovi ID.

 → Costruire contesto di categorie.

 → Classificare con Gemini Flash.

 → Eseguire il parsing della risposta IA.

 → Preparare i risultati per il nuovo Google Sheet.

 → Scrivere nel nuovo Google Sheet.

Prima ti racconto il funzionamento del flusso a grandi linee e poi spieghiamo in dettaglio ciascuno.

In questo flusso, n8n viene eseguito con una frequenza definita, legge il foglio delle risposte, normalizza i dati, scarta i record già elaborati, aggiunge le categorie che l’IA deve usare, invia i campi aperti a Gemini, interpreta la risposta e scrive una riga arricchita nel foglio finale.

Ora andiamo nodo per nodo.

Passo 1: Ogni ora

Questo nodo è il trigger del workflow.  

Nell’esempio è configurato per essere eseguito ogni ora, ma la frequenza può essere adattata al volume di risposte.  

Se ricevi molte risposte, può avere senso eseguirlo ogni ora. Se ne ricevi poche, forse basta una volta al giorno. 

Dovrai anche lanciarlo manualmente durante una fase di test.

Configurazione di base:

Node type: Schedule Trigger
Rule: every hour

La chiave è regolare la frequenza. Per feedback dei moduli, normalmente non serve elaborare ogni minuto. 

Passo 2: Leggere Google Sheets origine

Questo nodo legge il foglio di Google Sheets dove si trovano le risposte originali del modulo.  

In questo caso usiamo la scheda di origine in sola lettura. 

Importante: non marchiamo righe, non scriviamo stati e non usiamo questo foglio come database operativo.

Potremmo farlo, ma siccome questo foglio lo ha creato il cliente, è preferibile non toccarlo. Se è del tuo business, probabilmente ha senso aggiungergli un secondo foglio, invece di creare un altro Google Sheet come facciamo qui.

Configurazione di base:

Node type: Google Sheets
Operation: Read
Document ID: [ID_DEL_SPREADSHEET_ORIGEN]
Sheet name: [NOMBRE_HOJA_ORIGEN]
Credential: [CREDENCIAL_GOOGLE_SHEETS]

Il foglio di origine deve essere il più pulito possibile. 

Se viene da Google Forms, avrai già una struttura abbastanza comoda. Se viene da un CRM o da diversi moduli, conviene prima unificare le risposte in un foglio con colonne coerenti.

Passo 3: Impacchettare origine

Questo nodo di codice (JS) normalizza le righe che arrivano dal foglio di origine e le lascia preparate per il resto del workflow.  

In pratica, copia ogni item così com’è. 

Codice del nodo:

// Normaliza las filas del Sheets origen para usarlas despues desde otros nodos.
// El origen es solo lectura, asi que no marcamos nada aqui.

return $input.all().map(item => ({
  json: { ...item.json }
}));

Passo 4: Filtrare nuovi Record ID

Questo nodo evita duplicati. 

È uno dei punti più importanti del workflow. Se ogni volta che si esegue il flusso inviassimo tutte le risposte a Gemini, elaboreremmo sempre gli stessi commenti, spenderemmo più token e riempiremmo il foglio finale di duplicati.

Per evitarlo usiamo il nodo Remove Duplicates di n8n con l’operazione Remove Items Processed in Previous Executions. La configurazione si basa sul campo Record ID, che deve essere univoco per ogni risposta.

Configurazione di base:

Node type: Remove Duplicates
Operation: Remove Items Processed in Previous Executions
Value to Dedupe On: {{ $json["Record ID"] }}

Questo è importante:

Se il workflow viene montato prima che ci siano risposte, non bisogna inizializzare nulla. La prima risposta che arriverà sarà nuova e verrà elaborata.

Se il foglio ha già risposte vecchie quando attivi il workflow (caso abituale), conviene eseguire l’intero flusso fino a questo nodo (incluso) prima di collegarlo al resto del flusso. 

Così n8n impara quei Record ID come già visti e non manda tutto lo storico all’IA nella prima esecuzione.

Conviene anche provare il flusso senza pubblicarlo ancora: eseguire una volta, controllare quali record passano, eseguire di nuovo e verificare che non si duplicano. 

Non premere Clear Deduplication Historya meno che tu non voglia rielaborare tutto.

Passo 5: Costruire contesto di categorie

Qui definiamo le categorie che l’IA può usare per classificare le risposte.  

Questo punto è chiave perché non vogliamo che Gemini inventi una categoria diversa per ogni commento. Vogliamo che classifichi dentro un quadro chiuso.

In questo esempio abbiamo due gruppi di categorie: uno per problemi del processo di prenotazione e un altro per commenti aperti.

Categorie per Q3, problemi del processo:

• Pagamento / gateway.
• Codice sconto.
• Navigazione / UX.
• Disponibilità errata.
• Problemi con la prenotazione.
• Altro.

Categorie per Q5, commenti aperti:

• Soddisfazione / elogio.
• Promozioni / sconti.
• Assistenza / supporto umano.
• Metodo di pagamento / bonifico.
• Prezzo.
• Confronto con la concorrenza.
• Informazioni del listing.
• Politica di cancellazione.
• Tempo di risposta.
• Nessun commento rilevante.
• Altro.

In questo caso abbiamo deciso di inserire le categorie direttamente nel codice dentro lo stesso nodo di codice per evitare una lettura aggiuntiva a Google Sheets.  

Non è solo una preferenza tecnica: aiuta a ridurre le chiamate all’API di Google Sheets.

Può sembrare comodo usare Google Sheets come se fosse un piccolo database: un foglio per risposte, un altro per categorie, un altro per rivedere elaborati, un altro per scrivere risultati. 

Ma se il flusso cresce, puoi trovarti con limiti di quota, come succedeva qui. 

Per questo in questo caso usiamo Google Sheets come ingresso e uscita, non come database generale del sistema (che userà quello che hai nella tua installazione di n8n, per default SQLite).

Codice del nodo:

// Categorías hardcodeadas para eliminar una lectura adicional a Google Sheets.
// Si cambias Categorias_Config, actualiza estas listas aquí.

const categoriasQ3 = [
  [
'Pago / pasarela',
'Tarjeta rechazada, fallo con Bancontact, Paypal u otro metodo de pago'
  ],
  [
'Codigo descuento',
'Cupon o codigo de descuento invalido que bloquea o impide completar el pago'
  ],
  [
'Navegacion / UX',
'Problemas de usabilidad en la web, ej. volver al listado, botones confusos'
  ],
  [
'Disponibilidad incorrecta',
'Fechas que desaparecen, alojamiento mostrado como disponible pero no lo esta'
  ],
  [
'Problemas con la reserva',
'Reserva equivocada, duplicada o cancelada por error del sistema, demora o ausencia de confirmacion de reserva, email de confirmacion o validacion del propietario'
  ],
  [
'Otro',
'Incidencia que no encaja en ninguna categoria anterior'
  ],
];

const categoriasQ5 = [
  [
'Satisfaccion / elogio',
'Comentarios positivos, felicitaciones, recomendacion del servicio o buena experiencia'
  ],
  [
'Promociones / descuentos',
'Peticiones de codigos promocionales, descuentos para clientes habituales o promociones'
  ],
  [
'Atencion / soporte humano',
'Peticiones de hablar con una persona, chat humano, soporte no automatizado o ayuda comercial'
  ],
  [
'Forma de pago / transferencia',
'Comentarios sobre transferencia, tarjeta, medios de pago disponibles o preferencia de pago'
  ],
  [
'Precio',
'Comentarios sobre subida de precios, coste percibido como alto o comparacion de precio'
  ],
  [
'Comparacion con competencia',
'Menciona explicitamente otra plataforma como Booking.com, Airbnb, Vrbo, etc.'
  ],
  [
'Informacion del listing',
'Falta de fotos, ubicacion/coordenadas poco claras, info de mascotas, descripcion del alojamiento'
  ],
  [
'Politica de cancelacion',
'Plazo de cancelacion gratuita considerado corto o poco flexible'
  ],
  [
'Tiempo de respuesta',
'Quejas sobre lentitud en la respuesta a consultas o soporte'
  ],
  [
'Sin comentario relevante',
"Respuestas vacias de contenido: 'No', 'nada que destacar', 'all good', etc."
  ],
  [
'Otro',
'Comentario con contenido pero que no encaja en ninguna categoria anterior'
  ],
];

const catsQ3 = categoriasQ3
  .map(([cat, desc]) => `- ${cat}: ${desc}`)
  .join('
');

const catsQ5 = categoriasQ5
  .map(([cat, desc]) => `- ${cat}: ${desc}`)
  .join('
');

return $input.all().map(item => ({
  json: {
...item.json,
    categorias_q3_texto: catsQ3,
categorias_q5_texto: catsQ5,
  }
}));

Ovviamente queste categorie non sono universali. Per altri business digitali andrebbero adattate. 

Passo 6: Classificare con Gemini Flash

Questo è il nodo che invia i campi aperti a Gemini. Nello specifico, analizziamo due campi: il dettaglio del problema durante la prenotazione e il commento libero finale.

Il modello deve restituire solo un JSON valido, senza spiegazioni, senza markdown e senza testo aggiuntivo. Questo è fondamentale perché il nodo successivo si aspetta di parsare quella risposta e convertirla in colonne.

Configurazione di base:

Node type: Google Gemini
Model: models/gemini-flash-lite-latest
Temperature: 0.1
Credential: [CREDENCIAL_GEMINI]

Prompt utilizzato:

Sei un classificatore di feedback di utenti di un sito di prenotazione di alloggi rurali. Devi analizzare due campi di testo e restituire SOLO un JSON valido, senza testo aggiuntivo, senza markdown, senza backticks.

Campo Q3 - Issue Detail (incidenza durante la prenotazione): "{{ $json['Q3 - Issue Detail'] }}"

Categorie consentite per Q3 (scegline una, oppure usa esattamente il testo "Sin incidencia" se il campo è vuoto):
{{ $json.categorias_q3_texto }}

Campo Q5 - Comments (commento libero): "{{ $json['Q5 - Comments'] }}"

Categorie consentite per Q5 (scegline una, oppure usa esattamente il testo "Sin comentario relevante" se è vuoto o non aggiunge contenuto come 'No', 'nada', 'all good'):
{{ $json.categorias_q5_texto }}

Inoltre:
- Se Q5 menziona esplicitamente una piattaforma concorrente (Booking.com, Airbnb, Vrbo, Expedia, HomeAway o un'altra), indica menciona_competidor true e il nome rilevato. Se no, false e stringa vuota.
- Traduci il contenuto di Q5 in spagnolo in modo fedele e naturale in comentario_traducido_es. Se è vuoto, restituisci stringa vuota.
- Per Q3, oltre alla categoria, indica in causa_raiz_resumen una frase breve (massimo 8 parole) in spagnolo che riassuma la causa tecnica, utile per raggruppare incidenze simili anche se sono scritte in modo diverso. Se non c’è incidenza, stringa vuota.

Restituisci esattamente questo formato JSON:
{
  "q3_categoria": "",
  "q3_causa_raiz_resumen": "",
  "q5_categoria": "",
  "q5_menciona_competidor": false,
  "q5_competidor_detectado": "",
  "q5_comentario_traducido_es": ""
}

Il prompt fa diverse cose insieme: 

• Classifica e traduce Q3.
• Riassume una breve causa radice per i problemi.
• Classifica e traduce Q5.
• Rileva se viene menzionato un competitor e traduce il commento libero in spagnolo. 

Tutto questo torna in un JSON con campi fissi.

La parte importante è che il modello non decide liberamente cosa fare. Gli diamo categorie consentite, gli diamo il formato esatto di output e gli chiediamo di non aggiungere testo fuori dal JSON.

Passo 7: eseguire il parsing della risposta IA

Questo nodo converte la risposta di Gemini in colonne utili. 

Prima estrae il testo restituito dal modello, pulisce eventuali backticks o blocchi di markdown e poi prova a convertirlo in JSON.

Include anche uno strato di sicurezza: se l’IA restituisce qualcosa che non si può analizzare, marca la riga come Errore di classificazione. Così il flusso non si rompe per una risposta puntuale mal formata.

Inoltre, forza una regola importante per il nostro caso di esempio: se Q3 non ha dettaglio o l’utente ha indicato che non ha avuto problemi, la categoria di Q3 viene lasciata come “Sin incidencia”. 

Questo evita che l’IA interpreti un commento di Q5 come se fosse un problema del processo.

Codice del nodo:

function extractModelText(json) {
  // Caso Gemini n8n actual:
  // item.json.content.parts[0].text
  if (json?.content?.parts?.[0]?.text) {
return json.content.parts[0].text;
  }

  // Otros formatos posibles según nodo/modelo
  if (typeof json?.text === 'string') return json.text;
  if (typeof json?.message === 'string') return json.message;
  if (typeof json?.output === 'string') return json.output;
  if (typeof json?.content === 'string') return json.content;

  // OpenAI/LangChain style fallback
  if (json?.message?.content) return json.message.content;
  if (json?.choices?.[0]?.message?.content) return json.choices[0].message.content;

  return '';
}

function cleanJsonText(raw) {
  return String(raw || '')
.replace(/```json/gi, '')
.replace(/```/g, '')
.trim();
}

const items = $input.all();
const originales = $('Construir contexto de categorias').all();

return items.map((item, index) => {
  const raw = cleanJsonText(extractModelText(item.json));

  let parsed;

  try {
parsed = JSON.parse(raw);
  } catch (e) {
parsed = {
  q3_categoria: 'Error de clasificacion',
  q3_causa_raiz_resumen: '',
  q5_categoria: 'Error de clasificacion',
  q5_menciona_competidor: false,
  q5_competidor_detectado: '',
  q5_comentario_traducido_es: ''
};
  }

  const original = originales[index] ? originales[index].json : {};

  const q3HadIssues = String(original['Q3 - Had Issues'] || '').trim().toLowerCase();
  const q3Detail = String(original['Q3 - Issue Detail'] || '').trim();

  if (!q3Detail || q3HadIssues === 'no') {
parsed.q3_categoria = 'Sin incidencia';
parsed.q3_causa_raiz_resumen = '';
  }
 
  return {
json: {
  'Record ID': original['Record ID'],
  'Timestamp': original['Timestamp'],
  'Market': original['Market'],
  'Q1 - Ease of Booking': original['Q1 - Ease of Booking'],
  'Q2 - Decision Driver': original['Q2 - Decision Driver'],
  'Q2 - Other (Specify)': original['Q2 - Other (Specify)'],
  'Q3 - Had Issues': original['Q3 - Had Issues'],
  'Q3 - Issue Detail': original['Q3 - Issue Detail'],

  'Q3 - Cluster Causa Raiz': parsed.q3_categoria || '',
  'Q3 - Causa Raiz Resumen': parsed.q3_causa_raiz_resumen || '',

  'Q4 - NPS Score': original['Q4 - NPS Score'],
  'Q5 - Comments': original['Q5 - Comments'],

  'Q5 - Cluster Tema': parsed.q5_categoria || '',
  'Q5 - Menciona Competidor': parsed.q5_menciona_competidor ? 'Si' : 'No',
  'Q5 - Competidor Detectado': parsed.q5_competidor_detectado || '',
  'Q5 - Comentario Traducido ES': parsed.q5_comentario_traducido_es || '',

  'Country': original['Country'],
  'Gender': original['Gender'],
  'Age': original['Age'],
  'Reply Requested': original['Reply Requested'],
  'Fecha Procesado IA': new Date().toISOString()
}
  };
});

Se cambi il nome del nodo precedente, dovrai modificare questa riga:

const originales = $('Construir contexto de categorias').all();

In n8n, i riferimenti per nome del nodo devono coincidere esattamente. Per questo conviene usare nomi chiari e non cambiarli dopo senza rivedere il codice.

Passo 8: Preparare Resultados_IA

Questo nodo fa una pulizia finale prima di scrivere i dati nel foglio dei risultati. Elimina campi interni che servono solo durante il processo, come le categorie in testo che avevamo aggiunto per il prompt.

Codice del nodo:

// Limpia campos internos antes de escribir en Resultados_IA.

return $input.all().map(item => {
  const row = { ...item.json };
  delete row['_timestamp_unix'];
  delete row['_clasificacion_error'];
  delete row['_error_message'];
  delete row['categorias_q3_texto'];
  delete row['categorias_q5_texto'];

  return { json: row };
});

Questo passaggio non trasforma l’analisi, ma lascia l’output più pulito. 

Il foglio finale non deve salvare tutto ciò che è stato usato internamente per classificare, ma salvare i dati che poi analizzeremo.

Passo 9: Scrivere Resultados_IA

L’ultimo nodo scrive la riga arricchita in un nuovo foglio di Google Sheets. 

In questo caso usiamo un foglio chiamato Resultados_IA e l’operazione append, per aggiungere una nuova riga per ogni risposta elaborata.

Configurazione di base:

Node type: Google Sheets
Authentication: Service Account
Operation: Append
Document ID: [ID_DEL_SPREADSHEET_RESULTADOS]
Sheet name: [NOMBRE_HOJA_RESULTADOS]
Mapping mode: Auto-map input data
Credential: [CREDENCIAL_GOOGLE_SHEETS]

Il foglio finale contiene sia dati originali sia campi generati dall’IA. Per esempio:

• Record ID
• Timestamp
• Market
• Q1 – Ease of Booking
• Q2 – Decision Driver
• Q3 – Had Issues
• Q3 – Issue Detail
• Q3 – Cluster Causa Raiz
• Q3 – Causa Raiz Resumen
• Q4 – NPS Score
• Q5 – Comments
• Q5 – Cluster Tema
• Q5 – Menciona Competidor
• Q5 – Competidor Detectado
• Q5 – Comentario Traducido ES
• Country
• Gender
• Age
• Reply Requested
• Data elaborazione IA

Da qui in poi non abbiamo più solo risposte sparse. Abbiamo una tabella arricchita, con commenti tradotti, problemi raggruppati, temi classificati e campi pronti da usare nei grafici.

Cosa otteniamo alla fine del processo

Alla fine del workflow, ogni nuova risposta viene trasformata in una riga più utile per l’analisi. 

Continuiamo a conservare il dato originale, ma aggiungiamo strati che prima richiedevano revisione manuale.

In pratica otteniamo:

• Commenti aperti tradotti in spagnolo.
• Problemi classificati per causa radice.
• Commenti raggruppati per tema.
• Rilevamento di menzioni ai competitor.
• Una data di elaborazione IA.
• Una tabella pronta per collegarsi a Looker Studio.

Questo non sostituisce la revisione umana. Quello che fa è togliere lavoro meccanico.

Invece di iniziare leggendo cento commenti in cinque lingue, inizi vedendo temi, categorie, frequenze e commenti tradotti. Poi puoi già rivedere campioni e decidere quali azioni hanno senso, come vedremo nel prossimo e ultimo post della serie.

Errori abituali quando si automatizza feedback con IA

Partiamo dai più abituali.

Lasciare che l’IA inventi categorie

Se ogni esecuzione crea etichette nuove, dopo non potrai confrontare nulla. 

Perché il sistema funzioni, l’IA deve classificare dentro una lista chiusa o, almeno, molto controllata.

Non validare il JSON restituito dal modello

Anche se gli chiedi un formato concreto, qualche volta può rispondere male. Per questo il nodo di parsing deve pulire, provare a convertire in JSON e prevedere errori senza rompere tutto il flusso.

Non controllare i duplicati

Prima di pubblicare il workflow conviene eseguirlo in test e verificare che la stessa risposta non finisca più volte nel secondo foglio. 

Il nodo dei nuovi Record ID è ciò che evita che tu paghi due volte per la stessa classificazione e che sporchi il foglio finale.

Usare Google Sheets come database operativo

Google Sheets funziona molto bene come ingresso e uscita, ma non conviene fare letture costanti per tutto: categorie, stati, controlli, risultati e controllo degli elaborati. 

Se esageri, puoi trovarti con problemi di quota o con un flusso più fragile del necessario.

Pubblicare il flusso senza provarlo

Prima bisogna eseguirlo manualmente, rivedere quali dati entrano, quali dati escono, se il JSON si parsa bene, se non ci sono duplicati e se le categorie sono quelle desiderate.

Credere che l’IA eseguirà tutto il lavoro

L’IA classifica e traduce, ma il business deve comunque interpretare. 

Una categoria frequente non implica sempre un’azione immediata. Bisogna valutare volume, impatto, facilità di implementazione e contesto.

Prossimo passo: trasformare questi dati in una dashboard

Dopo questo workflow abbiamo già un foglio di risultati che completa il foglio originale del modulo. 

Non sappiamo solo cosa ha risposto ogni utente, ma abbiamo anche campi preparati per l’analisi: categorie, traduzioni, competitor, problemi e data di elaborazione.

Il prossimo e ultimo passo è:

Portare quei dati in una dashboard e generare la governance di monitoraggio.

Nel prossimo articolo vedremo come collegare i fogli di Google con Data Studio, quali metriche ha senso mostrare e come trasformare il feedback in una routine mensile di monitoraggio.

Perché automatizzare l’analisi non serve a nulla se poi nessuno guarda i dati, cosa che succede spesso.