Formulierantwoorden automatisch vertalen en classificeren met n8n en AI

In de twee vorige artikelen van deze reeks zagen we eerst waarom het de moeite waard is om klantfeedback te verzamelen en daarna hoe je een nuttig feedbackformulier maakt om te begrijpen wat er op een website of app gebeurt direct na een conversie.

In dit derde artikel gaan we een niveau dieper. We hebben het niet meer alleen over antwoorden verzamelen, maar over ze verwerken. 

Want de antwoorden op open velden van welk formulier dan ook analyseren kost tijd als je het niet automatiseert. Vooral als ze in meerdere talen binnenkomen.

De volledige reeks over hoe je klantfeedback verzamelt en gebruikt bestaat uit vier delen:

1. Waarom klantfeedback verzamelen onmisbaar is.
2. Hoe je een nuttig feedbackformulier maakt.
3. Hoe je AI gebruikt om open antwoorden te vertalen en te classificeren.
4. Hoe je die feedback omzet in dashboards en een maandelijkse opvolgroutine.

Hier richten we ons op het derde punt: een workflow bouwen met n8n, Google Sheets en Gemini om open formulierantwoorden te vertalen, classificeren en verrijken.

Welk probleem lossen we op met deze workflow

Gesloten vragen in het formulier zijn makkelijk te analyseren. 

Als je vraagt om de eenvoud van het proces (of iets anders) van één tot tien te beoordelen, de belangrijkste beslissingsreden, leeftijd, land of of de gebruiker problemen heeft gehad, wordt elk antwoord geclassificeerd met een waarde binnen een beperkt aantal waarden.

Het probleem verschijnt bij open antwoorden.

Daar legt de gebruiker in zijn eigen woorden uit wat er is gebeurd: dat hij informatie niet kon vinden, dat de betaling twijfels opriep, dat hij vergeleek met een ander platform waar het goedkoper was, dat hij een probleem had met een coupon in de checkout, dat hij met een persoon wilde praten of dat het proces duidelijk en snel was.

Dit soort commentaar is heel waardevol, maar heeft drie moeilijkheden:

1. Je moet het lezen.
2. Je moet de context begrijpen en interpreteren.
3. En als er meerdere talen zijn, moet je het vertalen of normaliseren voordat je het kunt vergelijken.

Als je weinig antwoorden hebt, kun je dat handmatig doen. Als je volume krijgt, verschillende markten hebt of opmerkingen in vijf talen, is het niet meer haalbaar. 

In het geval dat we als voorbeeld gebruiken, was het formulier opgezet in het Spaans, Nederlands, Frans, Engels en Duits. Daarom was het logisch om een AI-laag toe te voegen.

Het idee is niet dat AI voor het bedrijf beslist, maar dat het de data voorbereidt: 

1. Opmerkingen vertalen.
2. Incidenten classificeren.
3. Vermeldingen van concurrenten detecteren.
4. Een Google Sheets-document klaarzetten dat in de volgende stap kan worden geanalyseerd.

Wat we gaan bouwen

We gaan een n8n-workflow die het volgende doet:

1. Leest een Google Sheets-blad met formulierantwoorden.
2. Detecteert welke antwoorden nieuw zijn om geen duplicaten te verwerken.
3. Voegt een categoriecontext toe zodat de AI consistent classificeert.
4. Stuurt de open velden naar een LLM (Gemini, in ons geval).
5. Ontvangt een antwoord in JSON.
6. Zet die JSON om in kolommen met het juiste formaat.
7. Schrijft het eindresultaat naar een ander Google Sheets-blad met de AI-resultaten.

Het is geen universeel recept dat je zomaar kunt kopiëren zonder iets aan te passen. 

Het is aangepast aan een concreet klantfeedbackformulier op een reserveringswebsite, maar de logica is overdraagbaar naar een ecommerce, een opleiding, een dienstenwebsite of elk feedbackformulier over een digitaal asset waarin je open antwoorden wilt classificeren.

Tools die we gaan gebruiken

Voor deze flow gebruiken we meerdere concrete tools:

• n8n, als automatiseringstool.
•  Google Sheets, als invoer- en uitvoerblad.
• Gemini, als AI-model om te vertalen en te classificeren.
• Data Studio, dat de natuurlijke bestemming wordt om de data in het volgende artikel te visualiseren.

In dit geval gebruiken we Gemini Flash Lite omdat de taak relatief licht is: korte opmerkingen analyseren, een categorie kiezen, detecteren of er een concurrent voorkomt en een JSON teruggeven. Daarvoor hebben we niet het krachtigste model nodig, maar een snel, goedkoop en stabiel model.

In ons geval waren de verwachte kosten amper een paar cent per dag. We kozen ook voor de latest-versie van Flash Lite, omdat bij het vastpinnen van eerdere versies, zoals 2.0 of 2.5, beschikbaarheidsproblemen opdoken. 

En in een geautomatiseerde flow is stabiliteit minstens even belangrijk als kwaliteit.

De modeltemperatuur staat ingesteld op 0.1.  

Ook dat is bewust: hier zoeken we geen creativiteit, maar consistentie. 

We willen dat vergelijkbare antwoorden op een vergelijkbare manier worden geclassificeerd en dat het model het JSON-formaat respecteert dat we vragen.

Voordat je begint: hoe het antwoordenblad moet zijn voorbereid

Zoals ik in de vorige post uitlegde, hebben we vóór het bouwen van de workflow een Google Sheets-blad nodig met de originele antwoorden van het formulier.  

Dat kan rechtstreeks uit Google Forms komen, of het kan een blad zijn waarin we antwoorden hebben samengevoegd die uit een ander systeem komen, zoals een CRM of verschillende formulieren in verschillende talen.

Het belangrijkste is dat het blad een stabiele structuur heeft: één rij per antwoord en één kolom per vraag. 

In dit voorbeeld werken we met velden die bij de antwoorden horen:

• Record ID (dat we gebruiken om duplicaten te vermijden).
• Datum.
• Markt (het zijn vijf verschillende domeinen).

En de velden van de antwoorden zelf:

• Gemak van boeken (schaal 1-10).
• Beslissingsreden (5 mogelijkheden).
• Of er incidenten waren en het detail van het incident.
• Beoordeling van de website.
• Vrije opmerking.
• Land (dat is niet hetzelfde als markt, omdat een Fin op de Engelse website kan boeken).
• Gender.
• Leeftijd.
• En of de gebruiker een antwoord verwacht.

Je blad hoeft niet exact dezelfde kolommen te hebben. Het belangrijkste is dat er een unieke identificatie per antwoordis. In deze workflow gebruiken we Record ID om te weten welke rijen al zijn verwerkt en welke nieuw zijn.

Als je in meerdere talen werkt, is het handig om in alle talen dezelfde structuur van vragen en antwoorden aan te houden en alleen de vertaling te wijzigen. 

Zo kun je geaggregeerde data analyseren en tegelijk segmenteren op taal, land of markt. Dit alles zagen we in de vorige post over hoe je het formulier maakt.

Workflow in n8n stap voor stap

De volledige workflow is georganiseerd in negen hoofdnodes:

Elk uur:

 → Bron-Sheets lezen.

 → Bron verpakken.

 → Nieuwe ID’s filteren.

 → Categoriecontext bouwen.

 → Classificeren met Gemini Flash.

 → AI-antwoord parsen.

 → Resultaten voorbereiden voor het nieuwe Google Sheet.

 → Schrijven naar het nieuwe Google Sheet.

Eerst leg ik globaal uit hoe de flow werkt en daarna bespreken we elke node in detail.

In deze flow draait n8n met een ingestelde frequentie, leest het antwoordenblad, normaliseert de data, verwijdert al verwerkte records, voegt de categorieën toe die de AI moet gebruiken, stuurt de open velden naar Gemini, interpreteert het antwoord en schrijft een verrijkte rij in het eindblad.

Nu gaan we node voor node.

Stap 1: Elk uur

Deze node is de trigger van de workflow.  

In het voorbeeld is hij ingesteld om te draaien elk uur, maar de frequentie kan worden aangepast aan het volume antwoorden.  

Als je veel antwoorden ontvangt, kan het zinvol zijn hem elk uur uit te voeren. Als je er weinig ontvangt, is één keer per dag misschien genoeg. 

Je zult hem ook handmatig moeten starten tijdens een testfase.

Basisconfiguratie:

Node type: Schedule Trigger
Rule: every hour

De sleutel is de frequentie goed afstellen. Voor formulierfeedback hoef je normaal gesproken niet elke minuut te verwerken. 

Stap 2: Bron-Google Sheets lezen

Deze node leest het Google Sheets-blad waar de originele antwoorden van het formulier staan.  

In dit geval gebruiken we het brontabblad alleen-lezen. 

Belangrijk: we markeren geen rijen, schrijven geen statussen en gebruiken dit blad niet als operationele database.

We zouden dat kunnen doen, maar omdat dit blad door de klant is aangemaakt, is het beter om het niet aan te raken. Als het voor je eigen bedrijf is, is het waarschijnlijk logisch om er een tweede blad aan toe te voegen, in plaats van een ander Google Sheet aan te maken zoals we hier doen.

Basisconfiguratie:

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

Het bronblad moet zo schoon mogelijk zijn. 

Als het uit Google Forms komt, heb je al een vrij handige structuur. Als het uit een CRM of uit meerdere formulieren komt, is het verstandig de antwoorden eerst samen te voegen in een blad met consistente kolommen.

Stap 3: Bron verpakken

Deze code-node (JS) normaliseert de rijen die uit het bronblad komen en maakt ze klaar voor de rest van de workflow.  

In de praktijk kopieert hij elk item zoals het is. 

Code van de node:

// 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 }
}));

Stap 4: Nieuwe Record ID’s filteren

Deze node voorkomt duplicaten. 

Dit is een van de belangrijkste punten van de workflow. Als we telkens wanneer de flow draait alle antwoorden naar Gemini zouden sturen, zouden we dezelfde opmerkingen steeds opnieuw verwerken, meer tokens verbruiken en het eindblad vullen met duplicaten.

Om dat te vermijden gebruiken we de node Remove Duplicates van n8n met de operatie Remove Items Processed in Previous Executions. De configuratie is gebaseerd op het veld Record ID, dat uniek moet zijn voor elk antwoord.

Basisconfiguratie:

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

Dit is belangrijk:

Als de workflow wordt gebouwd voordat er antwoorden zijn, hoef je niets te initialiseren. Het eerste antwoord dat binnenkomt, is nieuw en wordt verwerkt.

Als het blad al oude antwoorden heeft wanneer je de workflow activeert (het gebruikelijke geval), is het verstandig de volledige flow tot en met deze node uit te voeren voordat je hem met de rest van de flow verbindt. 

Zo leert n8n die Record ID’s als al gezien en stuurt het niet de hele historie naar de AI bij de eerste uitvoering.

Het is ook verstandig de flow te testen zonder hem al te publiceren: één keer uitvoeren, controleren welke records doorgaan, opnieuw uitvoeren en verifiëren dat ze niet worden gedupliceerd. 

Druk niet op Clear Deduplication Historytenzij je alles opnieuw wilt verwerken.

Stap 5: Categoriecontext bouwen

Hier definiëren we de categorieën die de AI mag gebruiken om de antwoorden te classificeren.  

Dit punt is cruciaal, omdat we niet willen dat Gemini voor elke opmerking een andere categorie verzint. We willen dat het classificeert binnen een gesloten kader.

In dit voorbeeld hebben we twee groepen categorieën: één voor incidenten in het boekingsproces en één voor open opmerkingen.

Categorieën voor Q3, incidenten in het proces:

• Betaling / betaalgateway.
• Kortingscode.
• Navigatie / UX.
• Onjuiste beschikbaarheid.
• Problemen met de boeking.
• Anders.

Categorieën voor Q5, open opmerkingen:

• Tevredenheid / lof.
• Promoties / kortingen.
• Klantenservice / menselijke ondersteuning.
• Betaalmethode / overschrijving.
• Prijs.
• Vergelijking met concurrentie.
• Informatie van de listing.
• Annuleringsbeleid.
• Reactietijd.
• Geen relevante opmerking.
• Anders.

In dit geval besloten we de categorieën te hardcoden binnen de code-node zelf om een extra lezing naar Google Sheets te vermijden.  

Dit is niet alleen een technische voorkeur: het helpt het aantal calls naar de Google Sheets-API te verminderen.

Het kan handig lijken om Google Sheets te gebruiken alsof het een kleine database is: een blad voor antwoorden, een ander voor categorieën, een ander om verwerkte items te controleren, een ander om resultaten te schrijven. 

Maar als de flow groeit, kun je tegen quota-limieten aanlopen, zoals hier bij ons gebeurde. 

Daarom gebruiken we Google Sheets in dit geval als invoer en uitvoer, niet als algemene database van het systeem (dat de database gebruikt die je in je n8n-installatie hebt, standaard SQLite).

Code van de node:

// 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,
  }
}));

Uiteraard zijn deze categorieën niet universeel. Voor andere digitale bedrijven zouden ze moeten worden aangepast. 

Stap 6: Classificeren met Gemini Flash

Dit is de node die de open velden naar Gemini stuurt. Concreet analyseren we twee velden: het detail van het incident tijdens de boeking en de vrije eindopmerking.

Het model moet alleen een geldige JSON teruggeven, zonder uitleg, zonder markdown en zonder extra tekst. Dit is essentieel omdat de volgende node verwacht dat antwoord te parsen en om te zetten in kolommen.

Basisconfiguratie:

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

Gebruikte prompt:

Je bent een classifier van gebruikersfeedback voor een website voor het boeken van landelijke accommodaties. Je moet twee tekstvelden analyseren en ALLEEN een geldige JSON teruggeven, zonder extra tekst, zonder markdown, zonder backticks.

Veld Q3 - Issue Detail (incident tijdens de boeking): "{{ $json['Q3 - Issue Detail'] }}"

Toegestane categorieën voor Q3 (kies er één, of gebruik exact de tekst "Sin incidencia" als het veld leeg is):
{{ $json.categorias_q3_texto }}

Veld Q5 - Comments (vrije opmerking): "{{ $json['Q5 - Comments'] }}"

Toegestane categorieën voor Q5 (kies er één, of gebruik exact de tekst "Sin comentario relevante" als het leeg is of niets toevoegt, zoals 'No', 'nada', 'all good'):
{{ $json.categorias_q5_texto }}

Daarnaast:
- Als Q5 expliciet een concurrerend platform noemt (Booking.com, Airbnb, Vrbo, Expedia, HomeAway of een ander), geef menciona_competidor true en de gedetecteerde naam aan. Zo niet, false en een lege string.
- Vertaal de inhoud van Q5 trouw en natuurlijk naar het Spaans in comentario_traducido_es. Als het leeg is, geef een lege string terug.
- Geef voor Q3, naast de categorie, in causa_raiz_resumen een korte zin (maximaal 8 woorden) in het Spaans die de technische oorzaak samenvat, nuttig om vergelijkbare incidenten te groeperen, ook als ze anders zijn verwoord. Als er geen incident is, geef een lege string terug.

Geef exact dit JSON-formaat terug:
{
  "q3_categoria": "",
  "q3_causa_raiz_resumen": "",
  "q5_categoria": "",
  "q5_menciona_competidor": false,
  "q5_competidor_detectado": "",
  "q5_comentario_traducido_es": ""
}

De prompt doet meerdere dingen tegelijk: 

• Classificeert en vertaalt Q3.
• Vat een korte grondoorzaak samen voor incidenten.
• Classificeert en vertaalt Q5.
• Detecteert of er een concurrent wordt genoemd en vertaalt de vrije opmerking naar het Spaans. 

Dat alles komt terug in een JSON met vaste velden.

Het belangrijkste is dat het model niet vrij beslist wat het gaat doen. We geven toegestane categorieën, we geven het exacte outputformaat en we vragen het geen tekst buiten de JSON toe te voegen.

Stap 7: AI-antwoord parsen

Deze node zet het antwoord van Gemini om in bruikbare kolommen. 

Eerst haalt hij de tekst op die het model teruggeeft, verwijdert mogelijke backticks of markdownblokken en probeert die daarna om te zetten naar JSON.

Hij bevat ook een veiligheidslaag: als de AI iets teruggeeft dat niet kan worden geparsed, markeert hij de rij als Classificatiefout. Zo breekt de flow niet door één slecht gevormd antwoord.

Bovendien dwingt hij een belangrijke regel af voor ons voorbeeld: als Q3 geen detail heeft of de gebruiker aangaf geen problemen te hebben gehad, blijft de Q3-categorie op “Sin incidencia” staan. 

Dit voorkomt dat de AI een Q5-opmerking interpreteert alsof het een incident in het proces was.

Code van de node:

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

Als je de naam van de vorige node wijzigt, moet je deze regel aanpassen:

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

In n8n moeten verwijzingen op nodenaam exact overeenkomen. Daarom is het handig duidelijke namen te gebruiken en die daarna niet te wijzigen zonder de code te controleren.

Stap 8: Resultados_IA voorbereiden

Deze node doet een eindschoonmaak voordat de data naar het resultatenblad wordt geschreven. Hij verwijdert interne velden die alleen tijdens het proces dienen, zoals de tekstcategorieën die we voor de prompt hadden toegevoegd.

Code van de node:

// 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 };
});

Deze stap verandert de analyse niet, maar maakt de output schoner. 

Het eindblad hoeft niet alles te bewaren wat intern is gebruikt om te classificeren, maar wel de data die we daarna gaan analyseren.

Stap 9: Resultados_IA schrijven

De laatste node schrijft de verrijkte rij naar een nieuw Google Sheets-blad. 

In dit geval gebruiken we een blad met de naam Resultados_IA en de operatie append, om een nieuwe rij toe te voegen voor elk verwerkt antwoord.

Basisconfiguratie:

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]

Het eindblad bevat zowel originele data als door AI gegenereerde velden. Bijvoorbeeld:

• 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
• AI-verwerkingsdatum

Vanaf hier hebben we niet alleen losse antwoorden meer. We hebben een verrijkte tabel, met vertaalde opmerkingen, gegroepeerde incidenten, geclassificeerde thema’s en velden die klaar zijn voor grafieken.

Wat we aan het einde van het proces bereiken

Aan het einde van de workflow wordt elk nieuw antwoord omgezet in een nuttigere rij voor analyse. 

We bewaren de originele data nog steeds, maar voegen lagen toe die vroeger handmatige review vereisten.

In de praktijk krijgen we:

• Open opmerkingen vertaald naar het Spaans.
• Incidenten geclassificeerd op grondoorzaak.
• Opmerkingen gegroepeerd per thema.
• Detectie van vermeldingen van concurrenten.
• Een AI-verwerkingsdatum.
• Een tabel die klaar is om aan Looker Studio te koppelen.

Dit vervangt menselijke review niet. Wat het doet, is mechanisch werk wegnemen.

In plaats van te beginnen met het lezen van honderd opmerkingen in vijf talen, begin je met thema’s, categorieën, frequenties en vertaalde opmerkingen. Daarna kun je voorbeelden bekijken en beslissen welke acties zinvol zijn, zoals we zullen zien in de volgende en laatste post van de reeks.

Veelgemaakte fouten bij het automatiseren van feedback met AI

We beginnen met de meest voorkomende.

AI categorieën laten verzinnen

Als elke uitvoering nieuwe labels aanmaakt, kun je daarna niets vergelijken. 

Om het systeem te laten werken, moet AI classificeren binnen een gesloten of ten minste sterk gecontroleerde lijst.

De JSON die het model teruggeeft niet valideren

Ook als je om een concreet formaat vraagt, kan het soms verkeerd antwoorden. Daarom moet de parse-node opschonen, proberen naar JSON te converteren en fouten afvangen zonder de hele flow te breken.

Duplicaten niet controleren

Voordat je de workflow publiceert, is het verstandig hem in tests uit te voeren en te verifiëren dat hetzelfde antwoord niet meerdere keren in het tweede blad terechtkomt. 

De node voor nieuwe Record ID’s voorkomt dat je twee keer betaalt voor dezelfde classificatie en dat je het eindblad vervuilt.

Google Sheets gebruiken als operationele database

Google Sheets werkt heel goed als invoer en uitvoer, maar het is niet handig om voor alles constante lezingen te doen: categorieën, statussen, controles, resultaten en controle van verwerkte items. 

Als je overdrijft, kun je quota-problemen krijgen of een flow die fragieler is dan nodig.

De flow publiceren zonder hem te testen

Eerst moet je hem handmatig uitvoeren, controleren welke data binnenkomt, welke data eruit komt, of de JSON goed wordt geparsed, of er geen duplicaten zijn en of de categorieën de gewenste zijn.

Geloven dat AI al het werk zal uitvoeren

AI classificeert en vertaalt, maar het bedrijf moet nog steeds interpreteren. 

Een frequente categorie betekent niet altijd een onmiddellijke actie. Je moet volume, impact, implementatiegemak en context beoordelen.

Volgende stap: deze data omzetten in een dashboard

Na deze workflow hebben we al een resultatenblad dat het originele formulierblad aanvult. 

We weten niet alleen wat elke gebruiker heeft geantwoord, maar hebben ook velden voorbereid voor analyse: categorieën, vertalingen, concurrenten, incidenten en verwerkingsdatum.

De volgende en laatste stap is:

Die data naar een dashboard brengen en de opvolgingsgovernance opzetten.

In het volgende artikel zien we hoe je Google-bladen koppelt aan Data Studio, welke metrics zinvol zijn om te tonen en hoe je feedback omzet in een maandelijkse opvolgroutine.

Want het automatiseren van analyse heeft geen enkele zin als daarna niemand naar de data kijkt, wat meestal gebeurt.