Como traduzir e classificar respostas de formulários automaticamente com n8n e IA

Nos dois artigos anteriores desta série vimos primeiro por que vale a pena coletar feedback de clientes e, depois, como criar um formulário de feedback útil para entender o que acontece em um site ou app logo depois de uma conversão.

Neste terceiro artigo vamos um nível mais fundo. Já não estamos falando apenas de coletar respostas, mas de processá-las. 

Porque analisar as respostas dos campos abertos de qualquer formulário exige tempo se não for automatizado. Sobretudo se vierem em vários idiomas.

A série completa sobre como coletar e usar feedback de clientes tem quatro partes:

1. Por que coletar feedback de clientes é indispensável.
2. Como criar um formulário de feedback útil.
3. Como usar IA para traduzir e classificar respostas abertas.
4. Como transformar esse feedback em dashboards e em uma rotina mensal de acompanhamento.

Aqui vamos focar-nos no terceiro ponto: montar um workflow com n8n, Google Sheets e Gemini para traduzir, classificar e enriquecer respostas abertas de formulários.

Que problema resolvemos com este workflow

As perguntas fechadas do formulário são fáceis de analisar. 

Se você pergunta pela avaliação de um a dez da facilidade do processo (ou de qualquer outra coisa), pelo principal motivo de decisão, idade, país ou se o usuário teve problemas, cada resposta fica classificada dentro de um número limitado de variáveis.

O problema aparece com as respostas abertas.

É aí que o usuário explica com as próprias palavras o que aconteceu: que não encontrava uma informação, que o pagamento gerou dúvidas, que comparou com outra plataforma onde estava mais barato, que teve um problema com um cupom no checkout, que queria falar com uma pessoa ou que o processo foi claro e rápido.

Esse tipo de comentário é muito valioso, mas tem três dificuldades:

1. É preciso lê-lo.
2. É preciso entender e interpretar o contexto.
3. E, se houver vários idiomas, é preciso traduzi-lo ou normalizá-lo antes de o comparar.

Se você tem poucas respostas, dá para fazer à mão. Se começa a ter volume, mercados diferentes ou comentários em cinco idiomas, deixa de ser viável. 

No caso que usamos como exemplo, o formulário estava pensado em espanhol, neerlandês, francês, inglês e alemão. Por isso fazia sentido acrescentar uma camada de IA.

A ideia não é que a IA decida pelo negócio, mas que prepare o dado: 

1. Traduzir comentários.
2. Classificar incidências.
3. Detectar menções a concorrentes.
4. Deixar uma planilha do Google Sheets pronta para analisar no passo seguinte.

O que vamos construir

Vamos construir um workflow de n8n que faz o seguinte:

1. Lê uma planilha do Google Sheets com respostas de formulários.
2. Detecta que respostas são novas para não processar duplicados.
3. Acrescenta um contexto de categorias para que a IA classifique de forma consistente.
4. Envia os campos abertos para um LLM (Gemini, no nosso caso).
5. Recebe uma resposta em JSON.
6. Converte esse JSON em colunas com o formato correto.
7. Escreve o resultado final em outra planilha do Google Sheets com os resultados da IA.

Não é uma receita universal que possas copiar sem mexer em nada. 

Está adaptado a um formulário concreto de feedback de cliente em um site de reservas, mas a lógica pode ser transferida para um ecommerce, um curso, um site de serviços ou qualquer formulário de feedback sobre um ativo digital em que você queira classificar respostas abertas.

Ferramentas que vamos usar

Para este fluxo usamos várias ferramentas concretas:

• n8n, como ferramenta de automação.
•  Google Sheets, como planilha de entrada e de saída.
• Gemini, como modelo de IA para traduzir e classificar.
• Data Studio, que será o destino natural para visualizar os dados no artigo seguinte.

Neste caso usamos Gemini Flash Lite porque a tarefa é relativamente leve: analisar comentários curtos, escolher uma categoria, detectar se aparece um concorrente e devolver um JSON. Não precisamos do modelo mais potente para isso, mas de um modelo rápido, barato e estável.

No nosso caso, o custo previsto era de apenas alguns cêntimos por dia. Também escolhemos a versão latest do Flash Lite porque, ao fixar versões anteriores, como 2.0 ou 2.5, apareciam problemas de disponibilidade. 

E, num fluxo automatizado, a estabilidade importa tanto ou mais do que a qualidade.

A temperatura do modelo está configurada em 0.1.  

Isto também é intencional: aqui não procuramos criatividade, mas consistência. 

Queremos que respostas parecidas sejam classificadas de forma parecida e que o modelo respeite o formato JSON que lhe pedimos.

Antes de começar: como a planilha de respostas deve estar preparada

Como te expliquei no post anterior, antes de montar o workflow, precisamos de uma planilha do Google Sheets com as respostas originais do formulário.  

Pode vir diretamente do Google Forms ou pode ser uma planilha em que tenhamos unificado respostas que chegam de outro sistema, como um CRM ou vários formulários em idiomas diferentes.

O importante é que a planilha tenha uma estrutura estável: uma linha por resposta e uma coluna por pergunta. 

Neste exemplo trabalhamos com campos associados às respostas:

• Record ID (que usamos para evitar duplicados).
• Data.
• Mercado (são cinco domínios diferentes).

E os das respostas em si:

• Facilidade de reserva (escala 1-10).
• Motivo de decisão (5 possibilidades).
• Se teve incidências e detalhe da incidência.
• Avaliação do site.
• Comentário livre.
• País (não é o mesmo que mercado, já que um finlandês pode reservar no site inglês).
• Género.
• Idade.
• E se o usuário espera resposta.

Não é preciso que a sua planilha tenha exatamente as mesmas colunas. O importante é que exista um identificador único por resposta. Neste workflow usamos Record ID para saber que linhas já foram processadas e quais são novas.

Se trabalhas em vários idiomas, convém manter a mesma estrutura de perguntas e respostas em todos eles, variando apenas a tradução. 

Assim você pode analisar dados agregados e, ao mesmo tempo, segmentar por idioma, país ou mercado. Vimos tudo isso no post anterior sobre como criar o formulário.

Workflow em n8n passo a passo

O workflow completo fica organizado em nove nós principais:

A cada hora:

 → Ler planilha de origem.

 → Empacotar origem.

 → Filtrar ID novos.

 → Construir contexto de categorias.

 → Classificar com Gemini Flash.

 → Fazer parse da resposta da IA.

 → Preparar os resultados para a nova planilha do Google Sheets.

 → Escrever na nova planilha do Google Sheets.

Primeiro conto-te o funcionamento do fluxo por alto e depois explicamos cada um em detalhe.

Neste fluxo, o n8n é executado com uma frequência definida, lê a planilha de respostas, normaliza os dados, descarta registros já processados, acrescenta as categorias que a IA deve usar, envia os campos abertos ao Gemini, interpreta a resposta e escreve uma linha enriquecida na planilha final.

Agora vamos nó a nó.

Passo 1: A cada hora

Este nó é o gatilho do workflow.  

No exemplo está configurado para ser executado a cada hora, mas a frequência pode ser adaptada ao volume de respostas.  

Se você recebe muitas respostas, pode fazer sentido executá-lo a cada hora. Se você recebe poucas, talvez baste uma vez por dia. 

Também terás de o lançar manualmente durante uma fase de testes.

Configuração básica:

Node type: Schedule Trigger
Rule: every hour

A chave é ajustar a frequência. Para feedback de formulários, normalmente não é preciso processar a cada minuto. 

Passo 2: Ler a planilha de origem do Google Sheets

Este nó lê a planilha de Google Sheets onde estão as respostas originais do formulário.  

Neste caso usamos o separador de origem como apenas leitura. 

Importante: não marcamos linhas, não escrevemos estados e não usamos esta planilha como banco de dados operacional.

Poderíamos fazer isso, mas como esta planilha foi criada pelo cliente, é melhor não mexer nela. Se for do seu próprio negócio, provavelmente faz sentido acrescentar-lhe uma segunda planilha, em vez de criar outro Google Sheet como fazemos aqui.

Configuração básica:

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

A planilha de origem deve ser o mais limpa possível. 

Se vier do Google Forms, você já terá uma estrutura bastante confortável. Se vier de um CRM ou de vários formulários, vale unificar antes as respostas em uma planilha com colunas coerentes.

Passo 3: Empacotar origem

Este nó de código (JS) normaliza as linhas que vêm da planilha de origem e deixa-as preparadas para o resto do workflow.  

Na prática, copia cada item tal como está. 

Código do nó:

// 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: Filtrar Record ID novos

Este nó evita duplicados. 

É um dos pontos mais importantes do workflow. Se cada vez que o fluxo fosse executado enviássemos todas as respostas ao Gemini, processaríamos os mesmos comentários repetidamente, gastaríamos mais tokens e encheríamos a planilha final com duplicados.

Para o evitar usamos o nó Remove Duplicates do n8n com a operação Remove Items Processed in Previous Executions. A configuração baseia-se no campo Record ID, que deve ser único para cada resposta.

Configuração básica:

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

Isto é importante:

Se o workflow for montado antes de haver respostas, não é preciso inicializar nada. A primeira resposta que chegar será nova e será processada.

Se a planilha já tiver respostas antigas quando ativas o workflow (caso habitual), convém executar o fluxo inteiro até este nó (incluído) antes de o ligar ao resto do fluxo. 

Assim o n8n aprende esses Record ID como já vistos e não envia todo o histórico à IA na primeira execução.

Também convém testar o fluxo sem publicá-lo ainda: executar uma vez, verificar quais registros passam, executar de novo e confirmar que não se duplicam. 

Não carregues em Clear Deduplication History, a menos que você queira processar tudo novamente.

Passo 5: Construir contexto de categorias

Aqui definimos as categorias que a IA pode usar para classificar as respostas.  

Este ponto é chave porque não queremos que o Gemini invente uma categoria diferente para cada comentário. Queremos que classifique dentro de um quadro fechado.

Neste exemplo temos dois grupos de categorias: um para incidências do processo de reserva e outro para comentários abertos.

Categorias para Q3, incidências do processo:

• Pagamento / gateway.
• Código de desconto.
• Navegação / UX.
• Disponibilidade incorreta.
• Problemas com a reserva.
• Outro.

Categorias para Q5, comentários abertos:

• Satisfação / elogio.
• Promoções / descontos.
• Atendimento / suporte humano.
• Forma de pagamento / transferência.
• Preço.
• Comparação com concorrência.
• Informação do listing.
• Política de cancelamento.
• Tempo de resposta.
• Sem comentário relevante.
• Outro.

Neste caso decidimos hardcodear as categorias dentro do próprio nó de código para evitar uma leitura adicional ao Google Sheets.  

Isto não é apenas uma preferência técnica: ajuda a reduzir chamadas à API do Google Sheets.

Pode parecer conveniente usar o Google Sheets como se fosse um pequeno banco de dados: uma planilha para respostas, outra para categorias, outra para revisar processados, outra para escrever resultados. 

Mas, se o fluxo crescer, você pode esbarrar em limites de cota, como acontecia aqui. 

Por isso, neste caso usamos o Google Sheets como entrada e saída, não como banco de dados geral do sistema (que usará o que você tiver na sua instalação do n8n; por padrão, SQLite).

Código do nó:

// 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 categorias não são universais. Para outros negócios digitais seria preciso adaptá-las. 

Passo 6: Classificar com Gemini Flash

Este é o nó que envia os campos abertos para o Gemini. Em concreto, analisamos dois campos: o detalhe da incidência durante a reserva e o comentário livre final.

O modelo deve devolver apenas um JSON válido, sem explicações, sem markdown e sem texto adicional. Isto é fundamental porque o nó seguinte espera parsear essa resposta e convertê-la em colunas.

Configuração básica:

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

Prompt utilizado:

Você é um classificador de feedback de usuários de um site de reservas de alojamentos rurais. Deve analisar dois campos de texto e devolver APENAS um JSON válido, sem texto adicional, sem markdown, sem backticks.

Campo Q3 - Issue Detail (incidência durante a reserva): "{{ $json['Q3 - Issue Detail'] }}"

Categorias permitidas para Q3 (escolha uma, ou use exatamente o texto "Sin incidencia" se o campo estiver vazio):
{{ $json.categorias_q3_texto }}

Campo Q5 - Comments (comentário livre): "{{ $json['Q5 - Comments'] }}"

Categorias permitidas para Q5 (escolha uma, ou use exatamente o texto "Sin comentario relevante" se estiver vazio ou não trouxer conteúdo como 'No', 'nada', 'all good'):
{{ $json.categorias_q5_texto }}

Além disso:
- Se Q5 mencionar explicitamente uma plataforma concorrente (Booking.com, Airbnb, Vrbo, Expedia, HomeAway ou outra), indique menciona_competidor true e o nome detectado. Se não, false e string vazia.
- Traduza o conteúdo de Q5 para o espanhol de forma fiel e natural em comentario_traducido_es. Se estiver vazio, devolva string vazia.
- Para Q3, além da categoria, indique em causa_raiz_resumen uma frase curta (máximo 8 palavras) em espanhol que resuma a causa técnica, útil para agrupar incidências semelhantes mesmo que estejam redigidas de forma diferente. Se não houver incidência, string vazia.

Devolva exatamente este formato JSON:
{
  "q3_categoria": "",
  "q3_causa_raiz_resumen": "",
  "q5_categoria": "",
  "q5_menciona_competidor": false,
  "q5_competidor_detectado": "",
  "q5_comentario_traducido_es": ""
}

O prompt faz várias coisas ao mesmo tempo: 

• Classifica Q3 e traduz o conteúdo quando necessário.
• Resume uma causa raiz curta para incidências.
• Classifica e traduz Q5.
• Detecta se um concorrente é mencionado e traduz o comentário livre para o espanhol. 

Tudo isso volta num JSON com campos fixos.

A parte importante é que o modelo não decide livremente o que fazer. Damos-lhe categorias permitidas, damos-lhe o formato exato de saída e pedimos que não acrescente texto fora do JSON.

Passo 7: Parsear resposta IA

Este nó converte a resposta do Gemini em colunas úteis. 

Primeiro extrai o texto devolvido pelo modelo, limpa possíveis backticks ou blocos de markdown e depois tenta convertê-lo em JSON.

Também inclui uma camada de segurança: se a IA devolver algo que não pode ser parseado, marca a linha como Erro de classificação. Assim o fluxo não quebra por causa de uma resposta pontual mal formada.

Além disso, força uma regra importante para o nosso caso de exemplo: se Q3 não tem detalhe ou o usuário indicou que não teve problemas, a categoria de Q3 fica como Sin incidencia. 

Isto evita que a IA interprete um comentário de Q5 como se fosse uma incidência do processo.

Código do nó:

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 mudares o nome do nó anterior, terás de ajustar esta linha:

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

Em n8n, as referências por nome de nó devem coincidir exatamente. Por isso convém usar nomes claros e não os mudar depois sem rever o código.

Passo 8: Preparar Resultados_IA

Este nó faz uma limpeza final antes de escrever os dados na planilha de resultados. Elimina campos internos que só servem durante o processo, como as categorias em texto que tínhamos acrescentado ao prompt.

Código do nó:

// 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 passo não transforma a análise, mas deixa a saída mais limpa. 

A planilha final não precisa guardar tudo o que foi usado internamente para classificar, mas sim os dados que depois vamos analisar.

Passo 9: Escrever Resultados_IA

O último nó escreve a linha enriquecida em uma nova planilha do Google Sheets. 

Neste caso usamos uma planilha chamada Resultados_IA e a operação append, para acrescentar uma nova linha por cada resposta processada.

Configuração 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]

A planilha final contém tanto dados originais quanto campos gerados por IA. Por exemplo:

• 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 de processamento IA

A partir daqui já não temos apenas respostas soltas. Temos uma tabela enriquecida, com comentários traduzidos, incidências agrupadas, temas classificados e campos prontos para usar em gráficos.

O que conseguimos no final do processo

Ao terminar o workflow, cada nova resposta fica convertida numa linha mais útil para a análise. 

Continuamos a conservar o dado original, mas acrescentamos camadas que antes exigiam revisão manual.

Na prática conseguimos:

• Comentários abertos traduzidos para espanhol.
• Incidências classificadas por causa raiz.
• Comentários agrupados por tema.
• Deteção de menções a concorrentes.
• Uma data de processamento IA.
• Uma tabela pronta para conectar ao Data Studio.

Isto não substitui a revisão humana. O que faz é retirar trabalho mecânico.

Em vez de começar lendo cem comentários em cinco idiomas, você começa vendo temas, categorias, frequências e comentários traduzidos. Depois já pode revisar amostras e decidir que ações fazem sentido, como veremos no próximo e último post da série.

Erros habituais ao automatizar feedback com IA

Vamos aos mais habituais.

Deixar que a IA invente categorias

Se cada execução cria novas etiquetas, depois não poderás comparar nada. 

Para que o sistema funcione, a IA deve classificar dentro de uma lista fechada ou, pelo menos, muito controlada.

Não validar o JSON que o modelo devolve

Mesmo que peças um formato concreto, alguma vez pode responder mal. Por isso o nó de parse deve limpar, tentar converter para JSON e contemplar erros sem romper todo o fluxo.

Não verificar duplicados

Antes de publicar o workflow convém executá-lo em testes e verificar que a mesma resposta não acaba várias vezes na segunda planilha. 

O nó de Record ID novos é o que evita que pagues duas vezes pela mesma classificação e que sujes a planilha final.

Usar Google Sheets como banco de dados operacional

Google Sheets funciona muito bem como entrada e saída, mas não convém fazer leituras constantes para tudo: categorias, estados, verificações, resultados e controle de processados. 

Se abusar, você pode encontrar problemas de cota ou deixar o fluxo mais frágil do que o necessário.

Publicar o fluxo sem o testar

Primeiro é preciso executá-lo manualmente, rever que dados entram, que dados saem, se o JSON é parseado bem, se não há duplicados e se as categorias são as desejadas.

Acreditar que a IA executará todo o trabalho

A IA classifica e traduz, mas o negócio continua a ter de interpretar. 

Uma categoria frequente nem sempre implica uma ação imediata. É preciso avaliar volume, impacto, facilidade de implementação e contexto.

Próximo passo: converter estes dados num dashboard

Depois deste workflow já temos uma planilha de resultados que complementa a planilha original do formulário. 

Não só sabemos o que cada usuário respondeu, como também temos campos preparados para análise: categorias, traduções, concorrentes, incidências e data de processamento.

O próximo e último passo é:

Levar esses dados para um dashboard e gerar a governance de acompanhamento.

No próximo artigo veremos como conectar as planilhas do Google ao Data Studio, que métricas faz sentido mostrar e como converter o feedback em uma rotina mensal de acompanhamento.

Porque automatizar a análise não serve de nada se ninguém olha para os dados depois, o que costuma acontecer.