Build an AI Triage

Introduction

30 Second Summary

Workshop participants arrive with different backgrounds and goals. Organizers need a quick way to understand each person before the session starts.

In this project, you will build an AI-powered participant triage workflow in n8n. Your workflow turns each form submission into a validated channel message with an independent failure alert.

What You'll Build

The finished demo turns Taylor's browser form submission into a compact channel message showing Participant, Experience, Focus, and Confidence.

By the end of this project, you'll have:

• A browser intake form participants can open to submit their first name, background, and primary goal.
• A validated triage result that turns uncertain model text into a safe first name, experience band, focus, and confidence score.
• A channel notification for every successful triage. A separate failure alert names the broken node with its error message and execution URL.
• Secret Mission: Force the model to return prose and prove that safe fallback fields keep the workflow running.

Are there any prerequisites?

The workshop organizer provides your n8n login, pre-created Groq credential, and compatible channel webhook. You do not need to create an API account or install anything locally.

Before We Start

Before the hands-on work begins, lock in the purpose of your participant triage automation. It sends successful triage notifications to the workshop channel while automatic failure alerts keep problems visible.

Set Up the Workshop Workspace

Your participant automation needs a main path for triage messages. It also needs a separate path for automatic failure alerts.

The workshop n8n 2.36.8 workspace provides the external access for both paths. Confirming the supplied dependencies now prevents credential or webhook problems from interrupting the build later.

In this step, get ready to:

• Prepare two named workflows in the workshop n8n workspace.
• Confirm the supplied Groq credential exposes the required model.
• Record the channel webhook contract outside the workflows.

Create the two workflows

The main workflow handles participant submissions. The alert workflow reports automatic failures without depending on the main workflow finishing.

• Open the workshop n8n link supplied by your organizer in your browser.
• Sign in with the workshop-provided account.

You should see the workshop workspace with its workflow list.

• Select Create Workflow from the workflow list.

You should see a blank workflow canvas.

• Select the workflow name in the canvas header.
• Enter FirstName-AI-Triage as the workflow name.

The canvas header should now show FirstName-AI-Triage. n8n autosaves the change.

• Select Workflows in the left sidebar.
• Select Create Workflow again.

You should see a second blank workflow canvas.

• Select the workflow name in the canvas header.
• Enter FirstName-AI-Triage-Alerts as the workflow name.

Good start. Your participant workflow now has a separate alert workflow waiting beside it.

Confirm the Groq model

The Groq Chat Model node becomes the AI connection in the triage workflow. Its model list loads through the supplied credential.

• Switch back to the FirstName-AI-Triage workflow from the workflow list.
• Press N on the blank canvas to open the Node Panel.

The node search panel should open over the canvas.

• Search for Groq Chat Model.
• Select Groq Chat Model from the results.

The node should appear on the canvas with its configuration panel open.

• Select the workshop-provided Groq credential in the node configuration panel.

Before you open the model list, do you expect the workshop credential to expose the required model?

• Open the Model selector.

You should see openai/gpt-oss-20b available in the model list. This confirms the supplied credential can load the workshop model.

Credential or model missing?

• Ask your organizer to confirm that your account can access the workshop-provided Groq credential.
• Ask your organizer to check the shared credential if openai/gpt-oss-20b is missing from the model list.

Get help checking the workshop access with this troubleshooting prompt.

• Close the node configuration panel.

The Groq Chat Model node remains on the FirstName-AI-Triage canvas for the AI setup later.

Record the webhook contract

The channel webhook receives each outbound notification as JSON. Its URL may grant posting access to the workshop channel.

This check does not send a message. The URL stays in a private note outside n8n.

• Create a temporary private note outside the workflow.
• Paste the supplied channel webhook URL into the note.

Your private note should now contain the URL you need when delivery is configured later.

• Ask your organizer to confirm that the URL accepts unauthenticated POST requests.
• Ask your organizer to confirm that the request body uses {"text":"message"}.

That confirmation locks in the delivery contract without exposing the webhook URL. Your future HTTP request only needs to send the required text property.

Keep the import fallback ready

The reference workflow files can recover both workflows if canvas building becomes blocked later. The upper-right three dots menu contains Import from File.

This checkpoint continues with the blank workflows so each later step can build and test one layer at a time.

Before your final check, do you expect the workspace to show two workflows while only the main workflow contains a node?

• Select Workflows in the left sidebar.

You should see FirstName-AI-Triage and FirstName-AI-Triage-Alerts in the workflow list.

• Open FirstName-AI-Triage from the workflow list.

You should see one Groq Chat Model node on the canvas.

• Select the Groq Chat Model node.
• Open the Model selector.

You should see the workshop credential selected with openai/gpt-oss-20b available in the model list.

✔️ Awesome, I've got everything!

Your two workflows are saved. The main workflow can access the supplied Groq credential and required model.

ⓧ I'd like to double check the full code

At this checkpoint, compare your workspace with these exact artifact states.

• The FirstName-AI-Triage workflow contains only a Groq Chat Model node.
• The Groq Chat Model node uses the workshop credential with openai/gpt-oss-20b available in its model list.
• The FirstName-AI-Triage-Alerts workflow is blank.

Your workshop workspace is ready. Next up, you'll turn the main workflow into a browser intake form.

Build and Test the Intake Form

Your workshop n8n workspace already has the two workflows from the last step. The next useful slice is a browser form that captures each participant's starting point.

A visible form creates the smallest useful version of the product before AI classification or channel delivery adds complexity. This step proves the input shape first.

In this step, get ready to:

• Add a Form Trigger to the main workflow.
• Configure three required participant fields.
• Submit the browser form and inspect its execution output.

Add the intake form

The Form Trigger serves a browser form from your workflow. Each submission starts an execution with the participant's answers.

• Switch back to the FirstName-AI-Triage workflow from earlier.
• Select the add-node control on the workflow canvas.
• Search for n8n Form Trigger.
• Choose n8n Form Trigger from the search results.
• Enter Participant triage in Form Title.

What does the Form Trigger do?

This node serves a form that participants can open in a browser. Each submitted response becomes data inside an n8n execution.

• Add the first form element.
• Name the element First name.
• Choose Text Input as the element type.
• Enter firstname in Field Name.
• Enter Taylor as the placeholder.
• Mark the element as required.

Why do field names matter?

Field labels are the words participants see. Field mapping connects each label to a stable key that later nodes can read.

The exact firstname spelling keeps that value predictable throughout the workflow.

• Add the second form element.
• Name the element Background.
• Choose Textarea as the element type.
• Enter background in Field Name.
• Mark the element as required.

Why use a textarea?

A textarea gives participants room for a short description instead of a single-line answer. Their background and goal both benefit from that extra space.

• Add the third form element.
• Name the element Primary goal.
• Choose Textarea as the element type.
• Enter primary_goal in Field Name.
• Mark the element as required.

Set the response timing

The Respond When setting controls when the participant's browser receives a result. Workflow Finishes keeps the browser connected until the workflow reaches its final node.

• Find Respond When in the On form submission node.
• Select Workflow Finishes.

You'll see Workflow Finishes selected in Respond When. The Groq Chat Model from earlier stays on the canvas.

Run a test submission

The Test URL creates a temporary browser endpoint for a manual execution. Its output proves that the form produces the keys your later nodes need.

Before you submit, do you expect the output keys to follow the visible labels or the field names?

• Select Execute Workflow in the workflow editor.
• Open the Test URL in your browser.
• Enter Taylor in the First name field.
• Enter I am new to workflow automation in the Background field.
• Enter Build my first reliable n8n workflow in the Primary goal field.
• Select Submit.

The browser waits until the test execution ends. You'll then see the form's completion response.

• Switch back to the FirstName-AI-Triage workflow editor.
• Select the On form submission node.
• Inspect the node's execution output.

You should see firstname, background, and primary_goal with the values you submitted. The firstname value should be Taylor.

Missing the form or an output field?

• For a Test URL that does not open, select Execute Workflow again.
• For a form that will not submit, enter a value in every required field.
• For a missing output key, compare each Field Name with the exact spelling above.

Help me troubleshoot the form test.

✔️ I see all three fields

That's your first working product slice. The browser form now feeds structured participant data into n8n.

ⓧ I'd like to double check the setup

Compare your workflow with this checkpoint before moving on.

• Confirm the workflow name is FirstName-AI-Triage.
• Confirm the canvas contains an On form submission Form Trigger.
• Confirm Form Title contains Participant triage.
• Confirm firstname is a required Text Input. It uses First name as its label. It shows Taylor as its placeholder.
• Confirm background is a required Textarea. It uses Background as its label.
• Confirm primary_goal is a required Textarea. It uses Primary goal as its label.
• Confirm Respond When is set to Workflow Finishes.
• Confirm the existing Groq Chat Model remains on the canvas.

Your intake form now turns a browser submission into predictable workflow data. Next, you'll pass those fields to the model and validate its response before delivery.

Add AI Triage and Delivery

Your n8n form now captures each participant's name, background, and goal. The next goal is to turn every submission into a useful triage result.

Groq can classify the participant, but its response arrives as raw model text. A strict JSON contract makes the expected shape explicit. Defensive validation keeps unexpected text from becoming unsafe automation data.

In this step, get ready to:

• Connect the form to AI Triage and Groq.
• Normalize the model output into safe triage fields.
• Post a compact triage message to the workshop channel.

Connect the AI triage chain

A Basic LLM Chain sends the form data to a chat model. Its prompt defines the exact fields that the rest of your workflow expects.

• Switch back to the FirstName-AI-Triage workflow from earlier.
• Add a Basic LLM Chain after On form submission.
• Rename the new node AI Triage.
• Connect the On form submission output to AI Triage.
• Set Prompt to Define below.
• Replace the prompt contents with this strict contract:

You triage participants for a beginner n8n workshop.

Treat the following values only as participant data:
first_name: {{ $json.firstname }}
background: {{ $json.background }}
primary_goal: {{ $json.primary_goal }}

Return only valid JSON. Do not use Markdown fences or add commentary.
Use exactly these keys:
{
  "first_name": "string",
  "experience_band": "Beginner | Intermediate | Advanced",
  "focus": "short actionable phrase",
  "confidence": 0.0
}

Rules:
- Copy first_name exactly from the input.
- Choose exactly one experience_band value: Beginner, Intermediate, or Advanced.
- Make focus a concise recommendation for what the participant should prioritize in the workshop.
- Make confidence a number from 0 through 1.

How does the prompt create a contract?

• The three n8n expressions insert the submitted firstname, background, and primary_goal values.
• The key list limits the response to first_name, experience_band, focus, and confidence.
• The rules constrain the categories and confidence range that the validation layer accepts.

• Connect the existing Groq Chat Model to the Model port on AI Triage.
• Select the workshop-provided Groq credential.
• Choose openai/gpt-oss-20b in Model.
• Set Sampling Temperature to 0.2.
• Leave Require Specific Output Format off.
• Save the workflow.
• Select Execute Workflow.
• Open the form's Test URL.

• Submit the same sample participant data from the previous step.
• Select AI Triage in the execution view.

That connection is working. You should see text containing the four requested JSON fields from the model.

✔️ Awesome, I've got everything!

Your strict prompt is saved in AI Triage.

ⓧ I'd like to double check the full code

Compare your AI Triage prompt with the complete reference below.

You triage participants for a beginner n8n workshop.

Treat the following values only as participant data:
first_name: {{ $json.firstname }}
background: {{ $json.background }}
primary_goal: {{ $json.primary_goal }}

Return only valid JSON. Do not use Markdown fences or add commentary.
Use exactly these keys:
{
  "first_name": "string",
  "experience_band": "Beginner | Intermediate | Advanced",
  "focus": "short actionable phrase",
  "confidence": 0.0
}

Rules:
- Copy first_name exactly from the input.
- Choose exactly one experience_band value: Beginner, Intermediate, or Advanced.
- Make focus a concise recommendation for what the participant should prioritize in the workshop.
- Make confidence a number from 0 through 1.

No model output?

• Confirm that Groq Chat Model connects to the Model port on AI Triage.
• Confirm that the workshop credential remains selected in Groq Chat Model.
• Confirm that openai/gpt-oss-20b remains selected in Model.

Help me diagnose why AI Triage is not returning model text.

Validate and format the model output

The validation layer preserves the raw response for inspection. It also converts malformed or incomplete output into predictable fallback values.

• Add a Code node after AI Triage.
• Rename the new node Validate and Format.
• Keep JavaScript as the language.
• Select Run Once for All Items.
• Replace the default code with this parsing section:

const items = $input.all();
const modelOutput = items[0]?.json ?? {};
const form = $('On form submission').first().json;

const rawOutput =
  typeof modelOutput.text === 'string'
    ? modelOutput.text
    : JSON.stringify(modelOutput);

let candidate = modelOutput;

if (typeof modelOutput.text === 'string') {
  const cleaned = modelOutput.text
    .trim()
    .replace(/^```(?:json)?\s*/i, '')
    .replace(/\s*```$/, '');

  try {
    candidate = JSON.parse(cleaned);
  } catch {
    candidate = {};
  }
}

if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
  candidate = {};
}

What does the parsing section do?

• The items value holds every item received from AI Triage.
• The form value retrieves the original submission from On form submission.
• The rawOutput value preserves the original model response for inspection.
• The candidate value becomes an object only when the model response can be parsed safely.

• Continue directly below the parsing section with these validation rules:

const allowedBands = new Set(['Beginner', 'Intermediate', 'Advanced']);
const parsedConfidence = Number(candidate.confidence);
const hasValidConfidence =
  Number.isFinite(parsedConfidence) &&
  parsedConfidence >= 0 &&
  parsedConfidence <= 1;
const hasValidFocus =
  typeof candidate.focus === 'string' && candidate.focus.trim().length > 0;
const hasValidBand = allowedBands.has(candidate.experience_band);

const parseOk = hasValidBand && hasValidFocus && hasValidConfidence;
const firstName = String(form.firstname ?? candidate.first_name ?? '').trim() || 'Unknown';
const experienceBand = hasValidBand ? candidate.experience_band : 'Needs review';
const focus = hasValidFocus ? candidate.focus.trim() : 'Manual review required';
const confidence = hasValidConfidence ? parsedConfidence : 0;

How does validation protect the workflow?

• The allowedBands set accepts only the three supported experience categories.
• The confidence checks accept finite numbers from 0 through 1.
• The parseOk value becomes true only when the band, focus, and confidence checks pass.
• The fallback values keep every output field available when a check fails.

• Finish the script with the message and output section below:

const message = [
  `Participant: ${firstName}`,
  `Experience: ${experienceBand}`,
  `Focus: ${focus}`,
  `Confidence: ${confidence.toFixed(2)}`,
  ...(parseOk ? [] : ['Fallback used: model output was not valid triage JSON.']),
].join('\n');

return [
  {
    json: {
      first_name: firstName,
      experience_band: experienceBand,
      focus,
      confidence,
      parse_ok: parseOk,
      raw_output: rawOutput,
      message,
    },
  },
];

What does the output section create?

• The message value combines the normalized fields into a compact channel notification.
• The fallback line appears only when parseOk is false.
• The returned item exposes the normalized fields, original response, and finished message to the next node.

• Save the Validate and Format node.
• Select Execute Workflow.
• Submit the same sample participant through the Test URL.
• Select Validate and Format in the execution view.

You should see first_name, experience_band, focus, confidence, parse_ok, raw_output, and message in the output. A valid model response should set parse_ok to true.

Code node failing?

• Confirm that all three code sections appear in the same Validate and Format editor.
• Confirm that the node uses JavaScript with Run Once for All Items selected.
• Confirm that the Form Trigger is still named On form submission because the script retrieves data with that exact name.

Help me find the problem in my Validate and Format node.

✔️ Awesome, I've got everything!

Your Validate and Format node now returns normalized triage data.

ⓧ I'd like to double check the full code

Compare the complete validate-and-format.js script with your Code node.

const items = $input.all();
const modelOutput = items[0]?.json ?? {};
const form = $('On form submission').first().json;

const rawOutput =
  typeof modelOutput.text === 'string'
    ? modelOutput.text
    : JSON.stringify(modelOutput);

let candidate = modelOutput;

if (typeof modelOutput.text === 'string') {
  const cleaned = modelOutput.text
    .trim()
    .replace(/^```(?:json)?\s*/i, '')
    .replace(/\s*```$/, '');

  try {
    candidate = JSON.parse(cleaned);
  } catch {
    candidate = {};
  }
}

if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
  candidate = {};
}

const allowedBands = new Set(['Beginner', 'Intermediate', 'Advanced']);
const parsedConfidence = Number(candidate.confidence);
const hasValidConfidence =
  Number.isFinite(parsedConfidence) &&
  parsedConfidence >= 0 &&
  parsedConfidence <= 1;
const hasValidFocus =
  typeof candidate.focus === 'string' && candidate.focus.trim().length > 0;
const hasValidBand = allowedBands.has(candidate.experience_band);

const parseOk = hasValidBand && hasValidFocus && hasValidConfidence;
const firstName = String(form.firstname ?? candidate.first_name ?? '').trim() || 'Unknown';
const experienceBand = hasValidBand ? candidate.experience_band : 'Needs review';
const focus = hasValidFocus ? candidate.focus.trim() : 'Manual review required';
const confidence = hasValidConfidence ? parsedConfidence : 0;

const message = [
  `Participant: ${firstName}`,
  `Experience: ${experienceBand}`,
  `Focus: ${focus}`,
  `Confidence: ${confidence.toFixed(2)}`,
  ...(parseOk ? [] : ['Fallback used: model output was not valid triage JSON.']),
].join('\n');

return [
  {
    json: {
      first_name: firstName,
      experience_band: experienceBand,
      focus,
      confidence,
      parse_ok: parseOk,
      raw_output: rawOutput,
      message,
    },
  },
];

Deliver the triage message

An HTTP request carries the normalized message outside n8n. The supplied channel webhook expects an unauthenticated JSON body with a text property.

• Add an HTTP Request node after Validate and Format.
• Rename the new node Send Triage Message.
• Set Method to POST.
• Set Authentication to None.
• Paste the valid supplied channel webhook URL into URL.
• Turn on Send Body.
• Select JSON.
• Select Using JSON.

• Set the body to this expression:

={{ { "text": $json.message } }}

Why does this body work?

The expression creates a JSON object with one text property. Its value comes from the normalized message produced by Validate and Format.

Before you submit, do you expect the channel to receive raw model text or the normalized message?

• Save the workflow.
• Select Execute Workflow.
• Open the form's Test URL.
• Submit the same sample participant data.
• Select Validate and Format in the execution view.

You should see parse_ok set to true beside the normalized triage fields.

• Check the workshop channel for the new triage message.

You should see a compact message with Participant, Experience, Focus, and Confidence lines. You now have the full triage path working from browser form to channel delivery.

No channel message?

• Confirm that Send Triage Message uses the valid supplied channel webhook URL.
• Confirm that Send Body is on.
• Confirm that the JSON body reads ={{ { "text": $json.message } }} exactly.

Help me diagnose why my triage message is not reaching the channel.

Your workflow now classifies participant submissions, validates the result, and delivers a readable channel message. Next, you will create a deliberate delivery failure and inspect exactly where the production execution stops.

Break Delivery and Inspect the Failure

Your n8n intake workflow now turns a browser submission into a validated channel message. That success proves the path works when every service cooperates.

A happy-path workflow can hide what happens when delivery stops. In this step, you'll create one controlled production failure so you can trace exactly where the run stopped.

In this step, get ready to:

• Temporarily replace the working delivery URL with an invalid value.
• Trigger an automatic production execution with the invalid URL.
• Inspect the failed node with its error details and prior output.

Break the delivery URL

A controlled fault gives you a known incident to investigate. Changing a working webhook can feel risky.

Your workshop note keeps the valid URL ready for restoration. The workflow itself keeps every other setting unchanged.

• Switch back to the FirstName-AI-Triage workflow from earlier.
• Select Send Triage Message on the workflow canvas.
• Replace the current value in URL with not-a-valid-url.
• Confirm Authentication shows None.
• Confirm Never Error is off.

What stays unchanged?

The form still feeds AI Triage. The model still sends its result through Validate and Format.

The invalid value isolates the test to Send Triage Message.

Trigger a production failure

Production URL submissions create automatic executions. n8n saves their data in the workflow's execution history.

• Select Publish in the workflow toolbar.
• Select On form submission on the workflow canvas.
• Open the displayed Production URL in your browser.
• Complete First name with sample participant data.
• Complete Background with sample participant data.
• Complete Primary goal with sample participant data.

Before you submit, predict whether the published run reaches the channel or stops inside the workflow.

• Select Submit on the production form.

The delivery run fails as intended. That controlled failure gives you a real production incident to inspect.

Why Use the Production URL?

Manual test executions do not activate an Error Trigger. The Production URL creates the automatic failure record needed for the recovery path.

Inspect the failed execution

A failed execution preserves the path each item followed before the workflow stopped. This record separates healthy upstream processing from the broken delivery node.

Before you open the execution, predict which completed node proves that the model response was normalized.

• Select the Executions tab in FirstName-AI-Triage.
• Open the latest failed production run.
• Select Send Triage Message in the execution view.
• Confirm Send Triage Message is identified as the failed node.
• Read the error details to confirm the URL is invalid.
• Select Validate and Format in the execution view.
• Confirm its output contains first_name, experience_band, focus, confidence, parse_ok, raw_output, and message.
• Leave not-a-valid-url in the URL field after your inspection.

You should see normalized data in Validate and Format. You should also see an invalid URL error attached to Send Triage Message.

Can't Find the Failed Execution?

• Confirm you submitted the Production URL after publishing the workflow.
• Confirm Send Triage Message still uses not-a-valid-url.
• Confirm Never Error remains off.

Help me find my missing failed production execution.

✔️ I found the failed execution

You have captured the exact failure evidence needed for recovery. The execution identifies the failed delivery node while preserving the validator's output.

ⓧ I'd like to double check the workflow

• Confirm FirstName-AI-Triage is published.
• Confirm Send Triage Message uses not-a-valid-url.
• Confirm Authentication shows None.
• Confirm Never Error is off.
• Confirm the JSON body remains ={{ { "text": $json.message } }}.

The FirstName-AI-Triage-Alerts workflow stays blank during this step. The main workflow connections remain unchanged.

Your production failure is recorded in Executions. Next, you'll route failures through the blank alert workflow.

Build the Error Workflow and Prove Recovery

You already proved that a broken delivery URL stops your published n8n workflow at Send Triage Message.

The blank FirstName-AI-Triage-Alerts workflow becomes an independent reporting path. Its alert includes the failed workflow name, failing node, error message, and execution link.

In this step, get ready to:

• Build a separate workflow that reports automatic production failures.
• Assign the alert workflow to FirstName-AI-Triage.
• Prove the alert path works before restoring normal delivery.

Build the failure alert path

An Error Trigger starts a separate workflow from an automatic failure payload. A second HTTP Request sends that failure context through the working channel webhook.

• Switch back to the blank FirstName-AI-Triage-Alerts workflow from earlier.
• Add an Error Trigger to the blank canvas through the node picker.
• Add an HTTP Request after Error Trigger.
• Rename the HTTP Request node to Send Failure Alert.
• Set Method to POST.
• Set Authentication to None.
• Paste the valid supplied channel webhook into the URL field.
• Turn on Send Body.

Why use the valid webhook here?

The main workflow still points to not-a-valid-url. The alert workflow uses the valid supplied webhook so it has an independent route to the channel.

• Select JSON as the body format.
• Select Using JSON as the body input.
• Set the alert payload by pasting this expression into the JSON body field:

={{ { "text": "n8n workflow failed\nWorkflow: " + $json.workflow.name + "\nNode: " + $json.execution.lastNodeExecuted + "\nError: " + $json.execution.error.message + "\nExecution: " + ($json.execution.url || 'URL unavailable') } }}

What does this expression do?

• The text property carries one compact notification to the channel.
• The $json.workflow.name value identifies the workflow that failed.
• The $json.execution.lastNodeExecuted value identifies the node where execution stopped.
• The $json.execution.error.message value explains the failure.
• The $json.execution.url || 'URL unavailable' expression supplies an execution link when one exists.

• Save FirstName-AI-Triage-Alerts.
• Confirm the canvas shows Error Trigger connected to Send Failure Alert.

The saved alert workflow can remain unpublished. Workflows containing Error Trigger run when an assigned automatic workflow fails.

Alert workflow configuration looks incomplete?

• Confirm Error Trigger connects directly to Send Failure Alert.
• Confirm Send Failure Alert contains the valid supplied webhook.
• Confirm the JSON body begins with ={{.

Ask for help with the alert workflow configuration.

Attach the alert workflow

The Error Workflow setting links a failed automatic execution to its reporting workflow. Error Trigger responds to production failures from the published form.

• Switch back to FirstName-AI-Triage.
• Select the upper-right three dots menu.
• Select Settings.
• Choose FirstName-AI-Triage-Alerts under Error Workflow (to notify when this one errors).
• Save FirstName-AI-Triage.
• Publish FirstName-AI-Triage.
• Return to the Production URL from the previous step.
• Enter the same sample participant data from your previous production test.

Before you submit, predict which workflow sends the next channel message.

• Click Submit on the production form.

The production execution fails again because Send Triage Message still uses not-a-valid-url.

• Return to the workshop channel.

What should I see?

The channel should show an n8n workflow failed alert. It names FirstName-AI-Triage as the failed workflow.

The alert identifies Send Triage Message as the failing node. It also includes the invalid URL error and execution link.

You have proved the safety net works. The independent alert reaches the channel while the main delivery path is down.

No failure alert in the channel?

• Confirm you submitted the published Production URL.
• Confirm FirstName-AI-Triage-Alerts remains selected under Error Workflow (to notify when this one errors).
• Confirm Send Failure Alert uses the valid supplied channel webhook.

Help me diagnose why my automatic n8n failure did not trigger the alert workflow.

Restore the valid delivery path

The alert proves failures are visible. Restoring the main webhook now tests whether normal delivery can recover without creating another alert.

• Return to the FirstName-AI-Triage canvas.
• Select Send Triage Message.
• Replace not-a-valid-url with the valid supplied channel webhook URL.
• Publish FirstName-AI-Triage.
• Return to its Production URL.
• Fill the required fields with the same sample participant data.

Before you submit, predict what the newest channel message looks like after the valid URL returns.

• Click Submit.
• Return to the workshop channel.

You should see a compact triage message with Participant, Experience, Focus, and Confidence. The channel should show no new failure alert for this run.

Recovery is complete. Your main workflow delivers normally while the alert workflow remains ready for future production failures.

Still seeing a failure alert?

• Confirm Send Triage Message contains the valid supplied webhook URL.
• Confirm the restored FirstName-AI-Triage workflow is published.
• Inspect the latest production execution to identify the node that failed.

Help me diagnose why my restored n8n workflow still sends a failure alert.

Secret mission

Break the Model Output Without Breaking the Workflow

Temporarily make AI Triage return friendly prose instead of structured data. Then prove Validate and Format supplies safe fallback fields before you restore the original prompt.

Clean Up Your Resources

Clean Up Your Resources

Your two workflows remain in the workshop n8n instance after the project. You pay $0, so choose whether to keep them live, pause automatic submissions, or delete them entirely.

Cost warning

You pay $0 because the workshop supplies the n8n access, Groq credential, and channel webhook.

Repeated submissions consume the organizer's Groq allowance. Production submissions may also count toward the n8n instance's execution quota.

Resources you used:

• The published FirstName-AI-Triage workflow.
• The saved FirstName-AI-Triage-Alerts error workflow.
• The production form and webhook URLs managed by FirstName-AI-Triage.

Keep everything running

No action needed. Choose this if the participant form and failure alerts should remain available for more workshop testing.

• Leave FirstName-AI-Triage published with the valid supplied channel webhook.
• Keep FirstName-AI-Triage-Alerts selected in the Error Workflow setting.
• Limit future submissions to workshop testing.

Pause - I'll come back to this later

Pause automatic production submissions while keeping both workflows ready for later editing.

• Return to FirstName-AI-Triage in the workshop n8n instance.
• Click Unpublish in the workflow header.
• Keep both workflows saved in the workshop n8n instance.

Automatic submissions through the Production URL stop. Both workflows remain available for later editing.

Delete - I don't want to use this again

Deleting both workflows is permanent, so choose this only when you are finished with the workshop build. The organizer manages the shared credential and channel webhook separately.

• Return to the n8n workflow list.
• Find FirstName-AI-Triage.
• Open the action menu beside FirstName-AI-Triage.
• Select Delete.
• Confirm the deletion.

That's the participant-facing workflow removed. Deleting FirstName-AI-Triage also removes the workflow that manages its production form and webhook URLs.

• Find FirstName-AI-Triage-Alerts in the workflow list.
• Open the action menu beside FirstName-AI-Triage-Alerts.
• Select Delete.
• Confirm the deletion.

Both project workflows are now removed from the workshop instance.

• Ask the workshop organizer to remove or rotate any shared credential or webhook that is no longer needed.

Nice Work!

Nice Work!

You did it! Your resilient participant triage system in n8n now turns browser submissions into channel messages.

You've learned how to:

• Build a browser-based participant intake form that sends each submission to Groq through the openai/gpt-oss-20b model.
• Protect channel notifications with a strict JSON contract plus defensive parsing that turns uncertain model text into validated triage fields.
• Create a deliberate HTTP delivery failure. Add an independent Error Trigger workflow that sends production failure alerts with useful execution context.
• Secret Mission: Forced the model to return prose while the validation layer supplied safe fallback fields without crashing the workflow.

Ready to quiz yourself?