Så översätter och klassificerar du formulärsvar automatiskt med n8n och AI

I de två tidigare artiklarna i den här serien såg vi först varför det är värt att samla in kundfeedback och sedan hur man skapar ett användbart feedbackformulär för att förstå vad som händer på en webb eller i en app precis efter en konvertering.

I den här tredje artikeln går vi ett steg djupare. Nu handlar det inte bara om att samla in svar, utan om att bearbeta dem. 

För att analysera svaren från öppna fält i vilket formulär som helst tar tid om det inte automatiseras. Särskilt om de kommer på flera språk.

Den kompletta serien om hur man samlar in och använder kundfeedback består av fyra delar:

1. Varför det är nödvändigt att samla in kundfeedback.
2. Så skapar du ett användbart feedbackformulär.
3. Så använder du AI för att översätta och klassificera öppna svar.
4. Så omvandlar du den feedbacken till dashboards och en månadsrutin för uppföljning.

Här ska vi fokusera på den tredje punkten: att bygga ett workflow med n8n, Google Sheets och Gemini för att översätta, klassificera och berika öppna svar från formulär.

Vilket problem löser vi med detta workflow

Stängda frågor i formuläret är lätta att analysera. 

Om du frågar efter ett betyg från ett till tio på hur enkel processen var (eller något annat), huvudsakligt beslutsskäl, ålder, land eller om användaren haft problem, klassificeras varje svar med ett värde inom ett begränsat antal variabler.

Problemet uppstår med de öppna svaren.

Det är där användaren med egna ord förklarar vad som har hänt: att information saknades, att betalningen väckte tvivel, att de jämförde med en annan plattform där det var billigare, att de hade problem med en kupong i checkouten, att de ville prata med en person eller att processen var tydlig och snabb.

Den typen av kommentar är mycket värdefull, men den har tre svårigheter:

1. Den måste läsas.
2. Man måste förstå och tolka sammanhanget.
3. Och om det finns flera språk måste den översättas eller normaliseras innan den jämförs.

Har du få svar kan du göra det för hand. Men när volymen växer, marknaderna blir fler eller kommentarerna kommer på fem språk slutar det vara genomförbart. 

I exemplet vi använder var formuläret upplagt på spanska, nederländska, franska, engelska och tyska. Därför var det logiskt att lägga till ett AI-lager.

Tanken är inte att AI ska fatta beslut åt verksamheten, utan att den ska förbereda datan: 

1. Översätta kommentarer.
2. Klassificera incidenter.
3. Upptäcka omnämnanden av konkurrenter.
4. Lämna ett Google Sheets-dokument redo att analyseras i nästa steg.

Vad vi ska bygga

Vi ska bygga ett n8n-workflow som gör följande:

1. Läser ett Google Sheets-ark med formulärsvar.
2. Upptäcker vilka svar som är nya så att dubbletter inte behandlas.
3. Lägger till ett kategorisammanhang så att AI klassificerar konsekvent.
4. Skickar de öppna fälten till en LLM (Gemini, i vårt fall).
5. Tar emot ett svar i JSON.
6. Omvandlar denna JSON till kolumner med rätt format.
7. Skriver slutresultatet i ett annat Google Sheets-ark med AI-resultaten.

Det är inte ett universellt recept som du kan kopiera utan att ändra något. 

Det är anpassat till ett konkret kundfeedbackformulär på en bokningswebbplats, men logiken kan överföras till e-handel, en utbildning, en tjänstewebb eller vilket feedbackformulär som helst om en digital tillgång där du vill klassificera öppna svar.

Verktyg vi ska använda

För det här flödet använder vi flera konkreta verktyg:

• n8n, som automatiseringsverktyg.
•  Google Sheets, som in- och utdataark.
• Gemini, som AI-modell för att översätta och klassificera.
• Data Studio, som blir den naturliga destinationen för att visualisera datan i nästa artikel.

I det här fallet använder vi Gemini Flash Lite eftersom uppgiften är relativt lätt: analysera korta kommentarer, välja en kategori, upptäcka om en konkurrent nämns och returnera en JSON. Vi behöver inte den mest kraftfulla modellen för det, utan en snabb, billig och stabil modell.

I vårt fall var den beräknade kostnaden bara några cent per dag. Vi valde också latest-versionen av Flash Lite eftersom det uppstod tillgänglighetsproblem när vi låste äldre versioner, som 2.0 eller 2.5. 

Och i ett automatiserat flöde är stabilitet lika viktig som kvalitet, eller mer.

Modellens temperatur är satt till 0.1.  

Det är också avsiktligt: här söker vi inte kreativitet, utan konsekvens. 

Vi vill att liknande svar klassificeras på liknande sätt och att modellen respekterar det JSON-format vi ber om.

Innan du börjar: så ska svarsarket vara förberett

Som jag förklarade i förra inlägget behöver vi, innan vi bygger workflowet, ett Google Sheets-ark med formulärets original­svar.  

Det kan komma direkt från Google Forms eller vara ett ark där vi har samlat svar som kommer från ett annat system, som ett CRM eller flera formulär på olika språk.

Det viktiga är att arket har en stabil struktur: en rad per svar och en kolumn per fråga. 

I det här exemplet arbetar vi med fält kopplade till svaren:

• Record ID (som vi använder för att undvika dubbletter).
• Datum.
• Marknad (det är fem olika domäner).

Och själva svarsfälten:

• Hur lätt bokningen var (skala 1–10).
• Beslutsskäl (5 möjligheter).
• Om det fanns incidenter och detaljer om incidenten.
• Betyg på webbplatsen.
• Fri kommentar.
• Land (inte samma sak som marknad, eftersom en finländare kan boka på den engelska webbplatsen).
• Kön.
• Ålder.
• Och om användaren förväntar sig svar.

Ditt ark behöver inte ha exakt samma kolumner. Det viktiga är att det finns en unik identifierare per svar. I detta workflow använder vi Record ID för att veta vilka rader som redan har behandlats och vilka som är nya.

Om du arbetar på flera språk är det klokt att behålla samma struktur för frågor och svar i alla, och bara variera översättningen. 

Då kan du analysera aggregerade data och samtidigt segmentera efter språk, land eller marknad. Allt detta såg vi i förra inlägget om hur man skapar formuläret.

Workflow i n8n steg för steg

Det kompletta workflowet organiseras i nio huvudnoder:

Varje timme:

 → Läs Google Sheets-källa.

 → Paketera källan.

 → Filtrera nya ID.

 → Bygg kategorisammanhang.

 → Klassificera med Gemini Flash.

 → Parsea AI-svar.

 → Förbered resultaten för det nya Google Sheets-arket.

 → Skriv till det nya Google Sheets-arket.

Först berättar jag översiktligt hur flödet fungerar och sedan går vi igenom varje del i detalj.

I det här flödet körs n8n med en definierad frekvens, läser svarsarket, normaliserar datan, utesluter redan behandlade poster, lägger till de kategorier som AI ska använda, skickar de öppna fälten till Gemini, tolkar svaret och skriver en berikad rad i slutarket.

Nu går vi nod för nod.

Steg 1: Varje timme

Den här noden är triggern för workflowet.  

I exemplet är den konfigurerad för att köras varje timme, men frekvensen kan anpassas efter svarsmängden.  

Om du får många svar kan det vara rimligt att köra den varje timme. Får du få svar kanske det räcker en gång om dagen. 

Du behöver också köra den manuellt under en testfas.

Grundkonfiguration:

Node type: Schedule Trigger
Rule: every hour

Nyckeln är att justera frekvensen. För formulärfeedback behöver man normalt inte behandla varje minut. 

Steg 2: Läs Google Sheets-källan

Den här noden läser Google Sheets-arket där formulärets original­svar finns.  

I detta fall använder vi källfliken som skrivskyddad. 

Viktigt: vi markerar inga rader, skriver inga statusar och använder inte detta ark som operativ databas.

Vi skulle kunna göra det, men eftersom arket skapades av kunden är det bättre att inte röra det. Om det är för din egen verksamhet är det förmodligen rimligt att lägga till ett andra ark, i stället för att skapa ett annat Google Sheet som vi gör här.

Grundkonfiguration:

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

Källarket ska vara så rent som möjligt. 

Om det kommer från Google Forms har du redan en ganska bekväm struktur. Om det kommer från ett CRM eller flera formulär är det bäst att först slå samman svaren i ett ark med konsekventa kolumner.

Steg 3: Paketera källan

Den här kodnoden (JS) normaliserar raderna som kommer från källarket och lämnar dem redo för resten av workflowet.  

I praktiken kopierar den varje item precis som det är. 

Nodens kod:

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

Steg 4: Filtrera nya Record ID

Den här noden förhindrar dubbletter. 

Det är en av workflowets viktigaste punkter. Om vi varje gång flödet körs skickade alla svar till Gemini skulle vi behandla samma kommentarer om och om igen, spendera fler tokens och fylla slutarket med dubbletter.

För att undvika det använder vi noden Remove Duplicates i n8n med operationen Remove Items Processed in Previous Executions. Konfigurationen baseras på fältet Record ID, som måste vara unikt för varje svar.

Grundkonfiguration:

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

Viktigt här:

Om workflowet byggs innan det finns några svar behöver du inte initiera något. Det första svaret som kommer in blir nytt och behandlas.

Om arket redan har gamla svar när du aktiverar workflowet (det vanliga fallet) är det klokt att köra hela flödet fram till den här noden (inklusive) innan du kopplar det till resten av flödet. 

Då lär sig n8n dessa Record ID som redan sedda och skickar inte hela historiken till AI vid första körningen.

Det är också klokt att testa flödet utan att publicera det ännu: kör en gång, kontrollera vilka poster som passerar, kör igen och verifiera att de inte dupliceras. 

Tryck inte på Clear Deduplication Historyom du inte vill behandla allt igen.

Steg 5: Bygg kategorisammanhang

Här definierar vi de kategorier som AI kan använda för att klassificera svaren.  

Den här punkten är avgörande eftersom vi inte vill att Gemini ska hitta på en ny kategori för varje kommentar. Vi vill att den klassificerar inom ett slutet ramverk.

I det här exemplet har vi två kategorigrupper: en för incidenter i bokningsprocessen och en för öppna kommentarer.

Kategorier för Q3, incidenter i processen:

• Betalning / betalningsgateway.
• Rabattkod.
• Navigering / UX.
• Felaktig tillgänglighet.
• Problem med bokningen.
• Annat.

Kategorier för Q5, öppna kommentarer:

• Nöjdhet / beröm.
• Kampanjer / rabatter.
• Kundservice / mänsklig support.
• Betalningssätt / överföring.
• Pris.
• Jämförelse med konkurrent.
• Listinginformation.
• Avbokningspolicy.
• Svarstid.
• Ingen relevant kommentar.
• Annat.

I det här fallet valde vi att hårdkoda kategorierna i själva kodnoden för att undvika en extra läsning mot Google Sheets.  

Det är inte bara en teknisk preferens: det hjälper till att minska anropen till Google Sheets API.

Det kan verka bekvämt att använda Google Sheets som en liten databas: ett ark för svar, ett annat för kategorier, ett annat för att granska behandlade poster, ett annat för att skriva resultat. 

Men om flödet växer kan du stöta på kvotgränser, som vi gjorde här. 

Därför använder vi i detta fall Google Sheets som in- och utdata, inte som en allmän databas för systemet (som kommer att använda den du har i din n8n-installation, som standard SQLite).

Nodens kod:

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

Självklart är dessa kategorier inte universella. För andra digitala verksamheter måste de anpassas. 

Steg 6: Klassificera med Gemini Flash

Det här är noden som skickar de öppna fälten till Gemini. Konkret analyserar vi två fält: detaljen om incidenten under bokningen och den avslutande fria kommentaren.

Modellen ska bara returnera giltig JSON, utan förklaringar, utan markdown och utan extra text. Det är avgörande eftersom nästa nod förväntar sig att parsa svaret och omvandla det till kolumner.

Grundkonfiguration:

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

Prompt som används:

Du är en klassificerare av användarfeedback från en webbplats för bokning av lantliga boenden. Du ska analysera två textfält och returnera ENDAST giltig JSON, utan extra text, utan markdown, utan backticks.

Fält Q3 - Issue Detail (incident under bokningen): "{{ $json['Q3 - Issue Detail'] }}"

Tillåtna kategorier för Q3 (välj en, eller använd exakt texten "Sin incidencia" om fältet är tomt):
{{ $json.categorias_q3_texto }}

Fält Q5 - Comments (fri kommentar): "{{ $json['Q5 - Comments'] }}"

Tillåtna kategorier för Q5 (välj en, eller använd exakt texten "Sin comentario relevante" om det är tomt eller inte tillför innehåll som 'No', 'nada', 'all good'):
{{ $json.categorias_q5_texto }}

Dessutom:
- Om Q5 uttryckligen nämner en konkurrerande plattform (Booking.com, Airbnb, Vrbo, Expedia, HomeAway eller annan), ange menciona_competidor true och det upptäckta namnet. Om inte, false och tom sträng.
- Översätt innehållet i Q5 till spanska på ett troget och naturligt sätt i comentario_traducido_es. Om det är tomt, returnera tom sträng.
- För Q3, utöver kategorin, ange i causa_raiz_resumen en kort fras (max 8 ord) på spanska som sammanfattar den tekniska orsaken, användbar för att gruppera liknande incidenter även om de är formulerade olika. Om det inte finns någon incident, tom sträng.

Returnera exakt detta JSON-format:
{
  "q3_categoria": "",
  "q3_causa_raiz_resumen": "",
  "q5_categoria": "",
  "q5_menciona_competidor": false,
  "q5_competidor_detectado": "",
  "q5_comentario_traducido_es": ""
}

Prompten gör flera saker samtidigt: 

• Klassificerar och översätter Q3.
• Sammanfattar en kort grundorsak för incidenter.
• Klassificerar och översätter Q5.
• Upptäcker om en konkurrent nämns och översätter den fria kommentaren till spanska. 

Allt detta kommer tillbaka i en JSON med fasta fält.

Det viktiga är att modellen inte själv bestämmer fritt vad den ska göra. Vi ger den tillåtna kategorier, exakt utdataformat och ber den att inte lägga till text utanför JSON.

Steg 7: Parsea AI-svar

Den här noden omvandlar Geminis svar till användbara kolumner. 

Först extraherar den texten som modellen returnerar, rensar eventuella backticks eller markdown-block och försöker sedan konvertera den till JSON.

Den innehåller också ett säkerhetslager: om AI returnerar något som inte går att parsa markeras raden som Klassificeringsfel. På så sätt går flödet inte sönder på grund av ett enstaka felaktigt formaterat svar.

Dessutom tvingar den fram en viktig regel i vårt exempel: om Q3 inte har någon detalj eller användaren angav att det inte fanns några problem lämnas Q3-kategorin som Sin incidencia. 

Det hindrar AI från att tolka en Q5-kommentar som om den vore en incident i processen.

Nodens kod:

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

Om du ändrar namnet på föregående nod måste du justera den här raden:

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

I n8n måste referenser via nodnamn matcha exakt. Därför är det klokt att använda tydliga namn och inte ändra dem senare utan att granska koden.

Steg 8: Förbered Resultados_IA

Den här noden gör en slutrensning innan datan skrivs till resultatarket. Den tar bort interna fält som bara används under processen, som kategorierna i textform som vi hade lagt till för prompten.

Nodens kod:

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

Det här steget förändrar inte analysen, men gör utdata renare. 

Slutarket behöver inte spara allt som användes internt för klassificeringen, utan bara de data vi sedan ska analysera.

Steg 9: Skriv Resultados_IA

Den sista noden skriver den berikade raden i ett nytt Google Sheets-ark. 

I det här fallet använder vi ett ark som heter Resultados_IA och operationen append, för att lägga till en ny rad för varje behandlat svar.

Grundkonfiguration:

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]

Slutarket innehåller både originaldata och AI-genererade fält. Till exempel:

• 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

Härifrån har vi inte längre bara lösa svar. Vi har en berikad tabell, med översatta kommentarer, grupperade incidenter, klassificerade teman och fält som är redo att användas i diagram.

Vad vi får i slutet av processen

När workflowet är klart omvandlas varje nytt svar till en mer användbar rad för analys. 

Vi behåller fortfarande originaldatan, men lägger till lager som tidigare krävde manuell granskning.

I praktiken får vi:

• Öppna kommentarer översatta till spanska.
• Incidenter klassificerade efter grundorsak.
• Kommentarer grupperade efter tema.
• Upptäckt av konkurrentomnämnanden.
• Ett AI-bearbetningsdatum.
• En tabell redo att kopplas till Looker Studio.

Det här ersätter inte mänsklig granskning. Det tar bort mekaniskt arbete.

I stället för att börja med att läsa hundra kommentarer på fem språk börjar du med att se teman, kategorier, frekvenser och översatta kommentarer. Sedan kan du granska urval och bestämma vilka åtgärder som är rimliga, som vi ser i nästa och sista inlägg i serien.

Vanliga misstag när feedback automatiseras med AI

Här är de vanligaste.

Låta AI hitta på kategorier

Om varje körning skapar nya etiketter kan du inte jämföra något senare. 

För att systemet ska fungera måste AI klassificera inom en stängd lista eller åtminstone en mycket kontrollerad lista.

Inte validera den JSON som modellen returnerar

Även om du ber om ett konkret format kan den svara fel någon gång. Därför måste parse-noden rensa, försöka konvertera till JSON och hantera fel utan att bryta hela flödet.

Inte kontrollera dubbletter

Innan du publicerar workflowet bör du köra det i testläge och kontrollera att samma svar inte hamnar flera gånger i det andra arket. 

Noden för nya Record ID hindrar dig från att betala två gånger för samma klassificering och från att stöka till slutarket.

Använda Google Sheets som operativ databas

Google Sheets fungerar mycket bra som in- och utdata, men det är inte klokt att göra ständiga läsningar för allt: kategorier, statusar, kontroller, resultat och kontroll av behandlade poster. 

Om du överdriver kan du stöta på kvotproblem eller få ett flöde som är bräckligare än nödvändigt.

Publicera flödet utan att testa det

Först måste du köra det manuellt, kontrollera vilka data som går in, vilka data som kommer ut, om JSON parsas rätt, om det inte finns dubbletter och om kategorierna är de önskade.

Tro att AI kommer att göra hela jobbet

AI klassificerar och översätter, men verksamheten måste fortfarande tolka. 

En frekvent kategori innebär inte alltid en omedelbar åtgärd. Man måste väga volym, påverkan, enkel implementering och sammanhang.

Nästa steg: omvandla dessa data till en dashboard

Efter detta workflow har vi redan ett resultatark som kompletterar formulärets originalark. 

Vi vet inte bara vad varje användare har svarat, utan har också fält förberedda för analys: kategorier, översättningar, konkurrenter, incidenter och bearbetningsdatum.

Det nästa och sista steget är:

Ta dessa data till en dashboard och skapa governance för uppföljning.

I nästa artikel ser vi hur man kopplar Google-arken till Data Studio, vilka mätvärden som är rimliga att visa och hur man gör feedback till en månadsrutin för uppföljning.

Att automatisera analysen är meningslöst om ingen tittar på datan efteråt, vilket ofta händer.