> ## Content Index
> Fetch the complete content index at: https://linuxhandbook.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# Chapter 3: Build Your First Workflow in n8n
- URL: https://linuxhandbook.com/courses/n8n/build-your-n8n-workflow/
- Published: 2026-11-20T14:21:03.000Z
- Updated: 2026-11-20T14:21:03.000Z
- Author: Yash Kiran Patil
- Tags: n8n, #lessons-col, #lesson-duration-45m

We have learned what n8n is and explored its interface. Now we can look at how workflows are put together and build a first example. Before opening the editor, let’s clarify what a workflow is.

To explain the workflow component let’s make an example like this:

![](https://linuxhandbook.com/content/images/2026/11/image72-1.png)

This is an example of how a workflow would look in n8n, and it contains some important things that we need to understand.

## Workflow trigger

The first step that you will need to define when you need to build a workflow is the trigger. As the name explains, a trigger means the event that will make the workflow start working. For example, suppose you are building a workflow to assist users of your website. In this case, the trigger will be a chat message, meaning whenever you receive a message from the user, the workflow starts working and assists them depending on the question or the request.

A Manual Trigger starts a workflow only when you run it yourself. It is useful while building and testing, but it will not run automatically in production.

To add the trigger just click on the add the first step or from the + symbol in the right sidebar. Both do the same thing. This will open the sidebar and show the possible triggers that you can add to your workflow canvas like this:

![](https://linuxhandbook.com/content/images/2026/11/image119-3.png)

The open sidebar shows the triggers that you can choose from. If you add the first one (manual trigger) for example, it will show up on the canvas like this:

![](https://linuxhandbook.com/content/images/2026/11/image112-2.png)

With a Manual Trigger, you start a test from the editor. It is intended for building and testing, rather than for letting a customer start a production workflow.

The other type of trigger is the one discussed earlier and it is called on chat message. It means when you get a message, the workflow starts working.

Another one is called on app event, and you will use this type a lot. It means whenever something happens on an app that you add. For example, you can make the trigger whenever you receive an email, or whenever a folder is updated on Drive, or whenever a row is added in a database. All these are on app event triggers, and as I said, the trigger depends on the solution you build; each one will consist of a different trigger.

Another type of trigger that we have is called on schedule. As the name explains, this type of trigger basically means you schedule the workflow to start every hour, daily, or every day at a specific time depending on what you want. There are some solutions where you will need this type of trigger.

On form submission is another trigger type that you can use for a workflow. This means whenever the user submits a form, the workflow will start working. This type is also used a lot in automation solutions, for example if you build a review system that analyzes customer feedback.

You can also make the trigger a webhook call, which means the workflow starts if you receive an HTTP request from a service. This is also possible in n8n.

As you see, there are many types of triggers that you can use, and all depend on what you build. Each solution will need a specific trigger.

## Connection and Nodes

After we learn what a trigger is and the types of triggers we have in n8n, it's time to move on to learn nodes and connections. Nodes are basically the applications you add to the workflow. For example, you will make a workflow that reads emails and summarizes them. Your workflow will be something like this:

![](https://linuxhandbook.com/content/images/2026/11/image35-3.png)

Here we define a workflow. The trigger is manual, and we have nodes. Email is a node, AI is a node, and result processing is a node. So basically, everything that you add to the workflow is called a node. It could be an application, AI, or some logic. All of these are considered nodes.

In n8n, all nodes have some input and output. The node receives an input, processes it, and produces an output to the next node. If we take the example of the AI node, it receives the email from the previous node (in this case, it's the input), reads it, summarizes it, and produces the summarized version, which in this case is the output.

The connection is what connects the nodes with each other. If you see there is some kind of link between nodes, the connection is what takes the flow from one node to another. It takes the output of the previous node to be the input of the next node, and so on.

For this introduction, it is useful to think of three broad node roles: triggers, app or service nodes, and core nodes. A trigger starts a workflow; an app node connects to a supported service; and a core node handles built-in tasks such as conditions, editing fields, or making an HTTP request. The available integrations change over time, so check n8n’s current integrations catalog rather than relying on a fixed count.

A trigger is usually the starting node and therefore does not receive data from an earlier workflow node. Other nodes can receive input, process it, and pass output along their connections.

I think we got enough theory, and we can start to apply what we learned on the canvas by creating our first workflow. As we proceed, we will learn more things.

## Build Workflow

Now, because it's our first workflow, let's make it something simple just to learn how to use the canvas and get familiar with how n8n works in practice.

Before building any workflow, the first thing you will need to do is define what the workflow will do and define the steps that you will need to follow.

For a first project, we will build a feedback tracker. It collects feedback in a form, uses an AI model to extract the review and classify its sentiment, then stores the result in Airtable. This example teaches the canvas and data flow; it is not a production customer-support system.

The first thing we will need to do for any project is create a new workflow with a descriptive name. In this case, we will name this workflow "Feedback Tracker" or any name of your choice, just to make it descriptive and different from other workflows we will build.

![](https://linuxhandbook.com/content/images/2026/11/image96-3.png)

The second step is to define the trigger of our workflow, and here the trigger that we will use is On Form Submission, as we need to take some feedback from the user, so it will be a form.

Click on Add First Step and choose the trigger On Form Submission. It will appear like this:

![](https://linuxhandbook.com/content/images/2026/11/image10-4.png)

The first thing we will do is give the form a name and description. You can do whatever you want; it depends on the situation. Here we will make the name "User Feedback" and add a simple description:

![](https://linuxhandbook.com/content/images/2026/11/image78-1.png)

You can check how this will appear to the user by clicking on "Test This Trigger". It will show you the form like this:

![](https://linuxhandbook.com/content/images/2026/11/image45-2.png)

The form needs two fields: the user’s name and their feedback. Add a Text Input element for each, as shown here:

![](https://linuxhandbook.com/content/images/2026/11/image4-5.png)

The form now has two text fields, one for the name and one for the feedback. n8n offers other field types too; choose them according to the data your workflow needs.

![](https://linuxhandbook.com/content/images/2026/11/image36-1.png)

To test the trigger, enter a sample name and positive feedback, then select Submit. Use fictional, non-sensitive text for this tutorial:

![](https://linuxhandbook.com/content/images/2026/11/image16-1.png)

The trigger output contains the submitted fields. In this example, it includes the name and the feedback text.

Now, this output of the trigger will be the input of the next node that we will connect to this trigger.

Let's continue our workflow. We now have the review from the user. What we will do next is check whether this message is positive or negative. For this purpose, we can use AI to check the entered message and classify it as good or bad (negative).

During development, you can pin a test output so later node tests reuse the same sample data instead of requiring another form submission. Pinned data is a testing aid; unpin or refresh it when you want to test a different submission.

To pin this data, click on the pin icon on the trigger like this: 

![](https://linuxhandbook.com/content/images/2026/11/image29-3.png)

After this, you will see on the canvas that the data is pinned and can be used in upcoming tests when we click on Execute Workflow.

![](https://linuxhandbook.com/content/images/2026/11/image42-1.png)

Now we have the data. The next job is to classify it, and here we will need to use AI. We will give it the message we got from the user, and it will determine whether it is positive or negative.

The Information Extractor needs a language model. We will attach an OpenAI Chat Model for this example. You can use a different supported model node if you adapt the configuration.

## Extract Fields

Before classification, we will extract the part of the submission that contains the review. The Information Extractor node can return structured fields based on the input text and the attribute descriptions you provide.

After the trigger, click on the + symbol to add a node and search for Information Extractor in the side panel. Add it, and it will be like this:

![](https://linuxhandbook.com/content/images/2026/11/image92-1.png)

Now you may have a question: why do we need to extract information? It's just feedback. Good question, but in real cases, the feedback will not contain only a review. It may contain a lot of data that we don't need. In our case, we only want the part where the user judges our service. That's why we only need to extract that part from the whole text. Makes sense, right?

We will ask the model to return two fields: Review, containing the service review, and Feeling, classifying it as happy or not happy. These labels are examples for learning; model output can be wrong, so check the result before using it to make decisions.

How this Information Extractor node works is that you pass the field you want to extract information from in the top section where it says "Text". In our case, the field name that contains everything we need is called Feedback, so drag it from the output of the previous node and pass it into the Text field like this:

![](https://linuxhandbook.com/content/images/2026/11/image89-1.png)

Now we have the field. We can extract as much information as we want from it depending on the situation. In some cases, you may need to extract a lot of information from one field. In our case here, we just want two variables.

In the Attributes section is where we put the elements we want to extract. The first one we can call Review and the second we can call Feeling.

Add them like this:

![](https://linuxhandbook.com/content/images/2026/11/image4-4.png)

Keep the attributes as String fields. Add a name and a description for each attribute. The descriptions tell the model what information to return.

For the first field, the prompt will be something like:

"Extract only the part where the user gives a review about our service."

And for the second field, it will be something like:

"Analyze the review entered by the user and classify it as 'happy' if the review is positive; otherwise, classify it as 'not happy' if the review is negative."

Add these descriptions to the corresponding attributes and mark them as required, as shown here: 

![](https://linuxhandbook.com/content/images/2026/11/image31-2.png)

The Information Extractor defines the fields to return. The connected language model does the extraction and classification.

Now close this node and get back to the canvas. You will see a place to add a model like this: 

![](https://linuxhandbook.com/content/images/2026/11/image56-2.png)

Click on Model and search for OpenAI Chat Model and add it. It will be like this: 

![](https://linuxhandbook.com/content/images/2026/11/image9-1.png)

The credential setup depends on how you run n8n. On n8n Cloud, supported OpenAI Chat Model nodes can use Gateway credits, or you can connect your own OpenAI API key. For a self-hosted instance, create an API key in the OpenAI platform, then create an OpenAI credential in n8n and paste the key into its API Key field. Keep the key in n8n’s credential store; do not place it in a prompt, workflow field, screenshot, or exported workflow. OpenAI API usage is billed separately from ChatGPT subscriptions, so check current API pricing and account billing before testing. When you send feedback to a hosted model, that text is sent to the model provider; use fictional examples here and avoid sending private customer information unless you have approval and an appropriate data-handling basis.

With the model credential configured, test the Information Extractor node. Select Execute Step and inspect the output:

If you run it, it will show you something like this: 

![](https://linuxhandbook.com/content/images/2026/11/image103-1.png)

Check that the output contains the review and a Feeling value matching the sample. A model can misclassify or return unexpected text, so test both positive and negative examples and treat the result as a suggestion rather than a guaranteed decision.

## Add Database

The final step is to store the extracted fields in Airtable so they can be reviewed and analyzed later. The workflow will save the user’s name, extracted review, and sentiment label.

With n8n, there are a lot of choices that we can use as a database. You can easily use Google Sheets and store this data there, and in my work I see a lot of examples where clients work with Sheets. It helps a lot in analyzing data in a visual way.

For this walkthrough, we will use Airtable, a hosted database with tables, columns, and rows. Google Sheets or another supported storage service could serve the same teaching purpose.

Airtable organizes records in tables and fields. Its views and filtering features can help you inspect submitted feedback; review Airtable’s current plan limits before using it for a real project.

## n8n Credentials

To let n8n access Airtable, create an Airtable credential. Airtable supports Personal Access Tokens (PATs) and OAuth2\. Its older API keys are deprecated, so use a PAT for this example.

For example, if you work on your project and you want to use email, you will need to use your account, and these credentials allow you to do that.

Create or sign in to an Airtable account, then create a base and table for the example.

After you create an account, it will be something like this:

![](https://linuxhandbook.com/content/images/2026/11/image49-1.png)

Create a workspace if needed. In Airtable, a base contains tables, and each table contains records and fields.

After we create the workspace to organize the work, we can create a base (database). Again, you can choose any name you want. In my case, I will name it n8n-base, like this:

![](https://linuxhandbook.com/content/images/2026/11/image41-1.png)

After creating the base, you can create a table. Again, choose any name you want. For this example, we can name it "User Feedback" since we are building a solution for user reviews.

![](https://linuxhandbook.com/content/images/2026/11/image116-1.png)

Create three fields in the table: Name, Review, and Feeling. Use text fields; the Review field can use Long text.

![](https://linuxhandbook.com/content/images/2026/11/image23-1.png)

Match Airtable field types to the values you plan to write. Use text fields for Name and Feeling, and Long text for Review if you want to keep longer comments.

Now we are set. We created the database and the table is ready. The last thing is to start filling the table with information from n8n.

Now get back to the n8n canvas and after the Information Extractor node, click Add (+) and search for Airtable in the side panel. Click on it and it will be like this:

![](https://linuxhandbook.com/content/images/2026/11/image15-1.png)

Here, because we need to insert data into the table we created, we will need to choose Create a Record. Select it and click on it. It will be shown like this: 

![](https://linuxhandbook.com/content/images/2026/11/image85-1.png)

Now the first thing we need to do is add the Airtable credentials to n8n. If this is the first time you are setting it up, click on the Add Credential icon.

![](https://linuxhandbook.com/content/images/2026/11/image57-2.png)

It will take you to this page: 

![](https://linuxhandbook.com/content/images/2026/11/image27-1.png)

In n8n, open the Airtable credential help link for current setup instructions. Create a Personal Access Token in Airtable’s Builder Hub, add the data.records:read, data.records:write, and schema.bases:read scopes, and grant access only to the base used in this tutorial. Copy the token once and paste it into the Access Token field of the n8n Airtable credential. Do not share the token or include it in screenshots. Airtable’s older API keys are deprecated.

Open Airtable’s Personal Access Tokens page. The following screenshots show the token setup steps

![](https://linuxhandbook.com/content/images/2026/11/image65-4.png)

Click on Create a Token and it will show a page like this: 

![](https://linuxhandbook.com/content/images/2026/11/image74-2.png)

Give the token a descriptive name, add the required scopes, and choose access limited to the example base:

data.records:read   
data.records:write   
schema.bases:read

Like this:

![](https://linuxhandbook.com/content/images/2026/11/image-15.png)

Create the token and copy it into the Airtable credential in n8n, then save and test the credential. Treat the token like a password: keep it private, grant only the access required, and rotate it if it is exposed.

![](https://linuxhandbook.com/content/images/2026/11/image-16.png)

Now it's ready. You can go back and you will see the base and table that you created in Airtable available in n8n. Choose the base and the table we created before in Airtable, like this:

![](https://linuxhandbook.com/content/images/2026/11/image-17.png)

Map the fields from the correct node outputs. Use Name from the Form Submission trigger, and Review and Feeling from Information Extractor.

![](https://linuxhandbook.com/content/images/2026/11/image-18.png)

Execute the Airtable node to create a test record:

![](https://linuxhandbook.com/content/images/2026/11/image-19.png)

Open the Airtable table and confirm that the new record contains the expected values:

![](https://linuxhandbook.com/content/images/2026/11/image-20.png)

Confirm that the record was created and that each value landed in the intended field. If a field is blank or the node reports a type error, check the field mapping and Airtable column types.

Now test a negative example as well. For instance, use the fictional name Alice and this sample feedback:

"I don't like the user experience. It's hard for me to use."

Unpin the earlier positive sample, submit or set up the negative example, and run the workflow again:

![](https://linuxhandbook.com/content/images/2026/11/image-21.png)

Check that the second record appears in Airtable and that the model returns the expected label. Results can vary, so verify the output rather than assuming every classification will be correct.

## Summary

In this chapter, we built a feedback tracker that receives a form submission, extracts a review and sentiment label with an AI model, then writes the values to Airtable. We used the workflow canvas, trigger data, node connections, model credentials, and an Airtable Personal Access Token.

For a real service, add validation and a human review step before acting on AI classifications. Decide what data you are allowed to collect, where it may be sent, who can access the Airtable base, and how long records should be kept. Keep API keys and tokens in n8n credentials, and test with synthetic data first.

In the next chapter, we will build a personal AI assistant using n8n!