Cómo traducir y clasificar respuestas de formularios automáticamente con n8n e IA

En los dos artículos anteriores de esta serie vimos primero por qué merece la pena recoger feedback de cliente y, después, cómo crear un formulario de feedback útil para entender qué ocurre en una web o app justo después de una conversión.

En este tercer artículo profundizamos un nivel más. Ya no hablamos solo de recoger respuestas, sino de procesarlas. 

Porque analizar las respuestas de los campos abiertos de cualquier formulario requiere tiempo si no se automatiza. Sobre todo si vienen en varios idiomas.

La serie completa acerca de cómo recoger y usar el feedback de cliente tiene cuatro partes:

1. Por qué recoger feedback de cliente es imprescindible.
2. Cómo crear un formulario de feedback útil.
3. Cómo usar IA para traducir y clasificar respuestas abiertas.
4. Cómo convertir ese feedback en dashboards y una rutina mensual de seguimiento.

Aquí nos vamos a centrar en el tercer punto: montar un workflow con n8n, Google Sheets y Gemini para traducir, clasificar y enriquecer respuestas abiertas de formularios.

Qué problema resolvemos con este workflow

Las preguntas cerradas del formulario son fáciles de analizar. 

Si preguntas por valorar del uno al diez la facilidad del proceso (o cualquier otra cosa), el motivo principal de decisión, la edad, el país o si el usuario ha tenido problemas, cada respuesta se clasifica con un valor entre un número acotado de variables.

El problema aparece con las respuestas abiertas.

Ahí es donde el usuario explica con sus palabras qué le ha pasado: que no encontraba una información, que el pago le generó dudas, que comparó con otra plataforma donde estaba más barato, que tuvo un problema con un cupón en el checkout, que quería hablar con una persona o que el proceso fue claro y rápido.

Ese tipo de comentario es muy valioso, pero tiene tres dificultades:

1. Hay que leerlo.
2. Hay que entender e interpretar el contexto.
3. Y, si hay varios idiomas, hay que traducirlo o normalizarlo antes de compararlo.

Si tienes pocas respuestas, puedes hacerlo a mano. Si empiezas a tener volumen, mercados distintos o comentarios en cinco idiomas, deja de ser factible. 

En el caso que usamos como ejemplo, el formulario estaba planteado en español, neerlandés, francés, inglés y alemán. Por eso tenía sentido añadir una capa de IA.

La idea no es que la IA decida por el negocio, sino que prepare el dato: 

1. Traducir comentarios.
2. Clasificar incidencias.
3. Detectar menciones a competidores.
4. Dejar un documento de Google Spreadsheets listo para analizar en el siguiente paso.

Qué vamos a construir

Vamos a construir un workflow de n8n que hace lo siguiente:

1. Lee una hoja de Google Sheets con respuestas de formularios.
2. Detecta qué respuestas son nuevas para no procesar duplicados.
3. Añade un contexto de categorías para que la IA clasifique de forma consistente.
4. Envía los campos abiertos a un LLM (Gemini, en nuestro caso).
5. Recibe una respuesta en JSON.
6. Convierte ese JSON en columnas con el formato correcto.
7. Escribe el resultado final en otra hoja de Google Sheets con los resultados de la IA.

No es una receta universal que puedas copiar sin tocar nada. 

Está adaptada a un formulario concreto de feedback de cliente en una web de reservas, pero la lógica se puede trasladar a un ecommerce, una formación, una web de servicios o cualquier formulario de feedback acerca de un activo digital donde quieras clasificar respuestas abiertas.

Herramientas que vamos a usar

Para este flujo usamos varias herramientas concretas:

• n8n, como herramienta de automatización.
•  Google Sheets, como hoja de entrada y de salida.
• Gemini, como modelo de IA para traducir y clasificar.
• Data Studio, que será el destino natural para visualizar los datos en el artículo siguiente.

En este caso usamos Gemini Flash Lite porque la tarea es relativamente ligera: analizar comentarios cortos, elegir una categoría, detectar si aparece un competidor y devolver un JSON. No necesitamos el modelo más potente para eso, sino un modelo rápido, barato y estable.

En nuestro caso el coste previsto era de apenas unos céntimos al día. También elegimos la versión latest de Flash Lite porque al fijar versiones anteriores, como 2.0 o 2.5, aparecían problemas de disponibilidad. 

Y en un flujo automatizado, la estabilidad importa tanto o más que la calidad.

La temperatura del modelo está configurada en 0.1. 

Esto también es intencionado: aquí no buscamos creatividad, sino consistencia. 

Queremos que respuestas parecidas se clasifiquen de forma parecida y que el modelo respete el formato JSON que le pedimos.

Antes de empezar: cómo debe estar preparada la hoja de respuestas

Como te expliqué en el post anterior, antes de montar el workflow, necesitamos una hoja de Google Sheets con las respuestas originales del formulario. 

Puede venir directamente de Google Forms o puede ser una hoja donde hayamos unificado respuestas que llegan desde otro sistema, como un CRM o varios formularios en distintos idiomas.

Lo importante es que la hoja tenga una estructura estable: una fila por respuesta y una columna por pregunta. 

En este ejemplo trabajamos con campos asociados a las respuestas:

• Record ID (que usamos para evitar duplicados).
• Fecha.
• Mercado (son cinco dominios diferentes).

Y los de las respuestas en sí:

• Facilidad de reserva (escala 1-10).
• Motivo de decisión (5 posibilidades).
• Si tuvo incidencias y detalle de la incidencia.
• Valoración de la web.
• Comentario libre.
• País (no es lo mismo que mercado, ya que un finlandés puede reservar en la web inglesa).
• Género.
• Edad.
• Y si el usuario espera respuesta.

No hace falta que tu hoja tenga exactamente las mismas columnas. Lo importante es que haya un identificador único por respuesta. En este workflow usamos Record ID para saber qué filas ya se han procesado y cuáles son nuevas.

Si trabajas en varios idiomas, conviene mantener la misma estructura de preguntas y respuestas en todos ellos, variando solo la traducción. 

Así puedes analizar datos agregados y, al mismo tiempo, segmentar por idioma, país o mercado. Todo esto lo vimos en el post anterior de cómo crear el formulario.

Workflow en n8n paso a paso

El workflow completo queda organizado en nueve nodos principales:

Cada hora:

 → Leer Sheets origen.

 → Empaquetar origen.

 → Filtrar ID nuevos.

 → Construir contexto de categorias.

 → Clasificar con Gemini Flash.

 → Parsear respuesta IA.

 → Preparar los resultados para el Google Sheet nuevo.

 → Escribir en el Google Sheet nuevo.

Primero te cuento el funcionamiento del flujo por encima y luego explicamos en detalle cada uno.

En este flujo, n8n se ejecuta con una frecuencia definida, lee la hoja de respuestas, normaliza los datos, descarta registros ya procesados, añade las categorías que debe usar la IA, envía los campos abiertos a Gemini, interpreta la respuesta y escribe una fila enriquecida en la hoja final.

Ahora vamos nodo por nodo.

Paso 1: Cada hora

Este nodo es el disparador del workflow. 

En el ejemplo está configurado para ejecutarse cada hora, pero la frecuencia se puede adaptar al volumen de respuestas. 

Si recibes muchas respuestas, puede tener sentido ejecutarlo cada hora. Si recibes pocas, quizá basta con una vez al día. 

También tendrás que lanzarlo manualmente durante una fase de pruebas.

Configuración básica:

Node type: Schedule Trigger
Rule: every hour

La clave es ajustar la frecuencia. Para feedback de formularios, normalmente no hace falta procesar cada minuto. 

Paso 2: Leer Google Sheets origen

Este nodo lee la hoja de Google Sheets donde están las respuestas originales del formulario. 

En este caso usamos la pestaña de origen como solo lectura. 

Importante: no marcamos filas, no escribimos estados y no usamos esta hoja como base de datos operativa.

Podríamos hacerlo, pero como esta hoja la creó el cliente, es preferible no tocarla. Si es de tu propio negocio, probablemente tiene sentido añadirle una segunda hoja, en vez de crear otro Google Sheet como hacemos aquí.

Configuración básica:

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

La hoja de origen debe ser lo más limpia posible. 

Si viene de Google Forms, ya tendrás una estructura bastante cómoda. Si viene de un CRM o de varios formularios, conviene unificar antes las respuestas en una hoja con columnas coherentes.

Paso 3: Empaquetar origen

Este nodo de código (JS) normaliza las filas que vienen de la hoja de origen y las deja preparadas para el resto del workflow. 

En la práctica, copia cada item tal cual. 

Código 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 }
}));

Paso 4: Filtrar Record ID nuevos

Este nodo evita duplicados. 

Es uno de los puntos más importantes del workflow. Si cada vez que se ejecuta el flujo mandáramos todas las respuestas a Gemini, procesaríamos una y otra vez los mismos comentarios, gastaríamos más tokens y llenaríamos la hoja final con duplicados.

Para evitarlo usamos el nodo Remove Duplicates de n8n con la operación Remove Items Processed in Previous Executions. La configuración se basa en el campo Record ID, que debe ser único para cada respuesta.

Configuración básica:

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

Importante esto:

Si el workflow se monta antes de que haya respuestas, no hay que inicializar nada. La primera respuesta que llegue será nueva y se procesará.

Si la hoja ya tiene respuestas antiguas cuando activas el workflow (caso habitual), conviene ejecutar el flujo entero hasta este nodo (incluído) antes de conectarlo al resto del flujo. 

Así n8n aprende esos Record ID como ya vistos y no manda todo el histórico a la IA en la primera ejecución.

También conviene probar el flujo sin publicarlo todavía: ejecutar una vez, comprobar qué registros pasan, volver a ejecutar y verificar que no se duplican. 

No pulses Clear Deduplication History salvo que quieras volver a procesarlo todo.

Paso 5: Construir contexto de categorías

Aquí definimos las categorías que la IA puede usar para clasificar las respuestas. 

Este punto es clave porque no queremos que Gemini invente una categoría distinta para cada comentario. Queremos que clasifique dentro de un marco cerrado.

En este ejemplo tenemos dos grupos de categorías: uno para incidencias del proceso de reserva y otro para comentarios abiertos.

Categorías para Q3, incidencias del proceso:

• Pago / pasarela.
• Código descuento.
• Navegación / UX.
• Disponibilidad incorrecta.
• Problemas con la reserva.
• Otro.

Categorías para Q5, comentarios abiertos:

• Satisfacción / elogio.
• Promociones / descuentos.
• Atención / soporte humano.
• Forma de pago / transferencia.
• Precio.
• Comparación con competencia.
• Información del listing.
• Política de cancelación.
• Tiempo de respuesta.
• Sin comentario relevante.
• Otro.

En este caso decidimos hardcodear las categorías dentro del propio nodo de código para evitar una lectura adicional a Google Sheets. 

Esto no es solo una preferencia técnica: ayuda a reducir llamadas a la API de Google Sheets.

Puede parecer cómodo usar Google Sheets como si fuera una pequeña base de datos: una hoja para respuestas, otra para categorías, otra para revisar procesados, otra para escribir resultados. 

Pero si el flujo crece, puedes encontrarte con límites de cuota, como nos pasaba aquí. 

Por eso en este caso usamos Google Sheets como entrada y salida, no como base de datos general del sistema (que usará la que tengas en tu instalación de n8n, por defecto SQLite).

Código 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,
  }
}));

Obviamente estas categorías no son universales. Para otros negocios digitales habría que adaptarlas. 

Paso 6: Clasificar con Gemini Flash

Este es el nodo que envía los campos abiertos a Gemini. En concreto, analizamos dos campos: el detalle de la incidencia durante la reserva y el comentario libre final.

El modelo debe devolver solo un JSON válido, sin explicaciones, sin markdown y sin texto adicional. Esto es fundamental porque el siguiente nodo espera parsear esa respuesta y convertirla en columnas.

Configuración básica:

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

Prompt utilizado:

Eres un clasificador de feedback de usuarios de una web de reservas de alojamientos rurales. Debes analizar dos campos de texto y devolver SOLO un JSON valido, sin texto adicional, sin markdown, sin backticks.

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

Categorias permitidas para Q3 (elige una, o usa exactamente el texto "Sin incidencia" si el campo esta vacio):
{{ $json.categorias_q3_texto }}

Campo Q5 - Comments (comentario libre): "{{ $json['Q5 - Comments'] }}"

Categorias permitidas para Q5 (elige una, o usa exactamente el texto "Sin comentario relevante" si esta vacio o no aporta contenido como 'No', 'nada', 'all good'):
{{ $json.categorias_q5_texto }}

Adicionalmente:
- Si Q5 menciona explicitamente una plataforma competidora (Booking.com, Airbnb, Vrbo, Expedia, HomeAway u otra), indica menciona_competidor true y el nombre detectado. Si no, false y cadena vacia.
- Traduce el contenido de Q5 al espanol de forma fiel y natural en comentario_traducido_es. Si esta vacio, devuelve cadena vacia.
- Para Q3, ademas de la categoria, indica en causa_raiz_resumen una frase corta (maximo 8 palabras) en espanol que resuma la causa tecnica, util para agrupar incidencias similares aunque esten redactadas de forma distinta. Si no hay incidencia, cadena vacia.

Devuelve exactamente este formato JSON:
{
  "q3_categoria": "",
  "q3_causa_raiz_resumen": "",
  "q5_categoria": "",
  "q5_menciona_competidor": false,
  "q5_competidor_detectado": "",
  "q5_comentario_traducido_es": ""
}

El prompt hace varias cosas a la vez: 

• Clasifica y traduce Q3.
• Resume una causa raíz corta para incidencias.
• Clasifica y traduce Q5.
• Detecta si se menciona un competidor y traduce el comentario libre al español. 

Todo eso vuelve en un JSON con campos fijos.

La parte importante es que el modelo no decide libremente qué hacer. Le damos categorías permitidas, le damos el formato exacto de salida y le pedimos que no añada texto fuera del JSON.

Paso 7: Parsear respuesta IA

Este nodo convierte la respuesta de Gemini en columnas útiles. 

Primero extrae el texto devuelto por el modelo, limpia posibles backticks o bloques de markdown y después intenta convertirlo en JSON.

También incluye una capa de seguridad: si la IA devuelve algo que no se puede parsear, marca la fila como Error de clasificación. Así el flujo no se rompe por una respuesta puntual mal formada.

Además, fuerza una regla importante para nuestro caso de ejemplo: si Q3 no tiene detalle o el usuario indicó que no tuvo problemas, la categoría de Q3 se deja como Sin incidencia. 

Esto evita que la IA interprete un comentario de Q5 como si fuera una incidencia del proceso.

Código 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()
}
  };
});

Si cambias el nombre del nodo anterior, tendrás que ajustar esta línea:

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

En n8n, las referencias por nombre de nodo deben coincidir exactamente. Por eso conviene usar nombres claros y no cambiarlos después sin revisar el código.

Paso 8: Preparar Resultados_IA

Este nodo hace una limpieza final antes de escribir los datos en la hoja de resultados. Elimina campos internos que solo sirven durante el proceso, como las categorías en texto que habíamos añadido para el prompt.

Código 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 };
});

Este paso no transforma el análisis, pero deja la salida más limpia. 

La hoja final no necesita guardar todo lo que se usó internamente para clasificar sino guardar los datos que luego vamos a analizar.

Paso 9: Escribir Resultados_IA

El último nodo escribe la fila enriquecida en una hoja nueva de Google Sheets. 

En este caso usamos una hoja llamada Resultados_IA y la operación append, para añadir una fila nueva por cada respuesta procesada.

Configuración básica:

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]

La hoja final contiene tanto datos originales como campos generados por IA. Por ejemplo:

• 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
• Fecha Procesado IA

A partir de aquí ya no tenemos solo respuestas sueltas. Tenemos una tabla enriquecida, con comentarios traducidos, incidencias agrupadas, temas clasificados y campos listos para usar en gráficos.

Qué conseguimos al final del proceso

Al terminar el workflow, cada respuesta nueva queda convertida en una fila más útil para el análisis. 

Seguimos conservando el dato original, pero añadimos capas que antes requerían revisión manual.

En la práctica conseguimos:

• Comentarios abiertos traducidos al español.
• Incidencias clasificadas por causa raíz.
• Comentarios agrupados por tema.
• Detección de menciones a competidores.
• Una fecha de procesamiento IA.
• Una tabla lista para conectarse a Looker Studio.

Esto no sustituye la revisión humana. Lo que hace es quitar trabajo mecánico.

En lugar de empezar leyendo cien comentarios en cinco idiomas, empiezas viendo temas, categorías, frecuencias y comentarios traducidos. Luego ya puedes revisar muestras y decidir qué acciones tienen sentido, como veremos en el siguiente y último post de la serie.

Errores habituales al automatizar feedback con IA

Vamos con los más habituales.

Dejar que la IA invente categorías

Si cada ejecución crea etiquetas nuevas, después no podrás comparar nada. 

Para que el sistema funcione, la IA debe clasificar dentro de una lista cerrada o, al menos, muy controlada.

No validar el JSON que devuelve el modelo

Aunque le pidas un formato concreto, alguna vez puede responder mal. Por eso el nodo de parseo debe limpiar, intentar convertir a JSON y contemplar errores sin romper todo el flujo.

No comprobar duplicados

Antes de publicar el workflow conviene ejecutarlo en pruebas y verificar que una misma respuesta no acaba varias veces en la segunda hoja. 

El nodo de Record ID nuevos es lo que evita que pagues dos veces por la misma clasificación y que ensucies la hoja final.

Usar Google Sheets como base de datos operativa

Google Sheets funciona muy bien como entrada y salida, pero no conviene hacer lecturas constantes para todo: categorías, estados, comprobaciones, resultados y control de procesados. 

Si abusas, puedes encontrarte con problemas de cuota o con un flujo más frágil de lo necesario.

Publicar el flujo sin probarlo

Primero hay que ejecutarlo manualmente, revisar qué datos entran, qué datos salen, si el JSON se parsea bien, si no hay duplicados y si las categorías son las deseadas.

Creer que la IA ejecutará todo el trabajo

La IA clasifica y traduce, pero el negocio sigue teniendo que interpretar. 

Una categoría frecuente no siempre implica una acción inmediata. Hay que valorar volumen, impacto, facilidad de implementación y contexto.

Siguiente paso: convertir estos datos en un dashboard

Después de este workflow ya tenemos una hoja de resultados que complementa la hoja original del formulario. 

No solo sabemos qué ha respondido cada usuario, sino que además tenemos campos preparados para análisis: categorías, traducciones, competidores, incidencias y fecha de procesamiento.

El siguiente y último paso es:

Llevar esos datos a un dashboard y generar el governance de seguimiento.

En el siguiente artículo veremos cómo conectar las hojas de Google con Data Studio, qué métricas tiene sentido mostrar y cómo convertir el feedback en una rutina mensual de seguimiento.

Porque automatizar el análisis no sirve de nada si nadie mira los datos después, que suele pasar.