Hello and welcome to video number five of the beginner course for n8n. In this video, we'll be covering some core workflow concepts and continue building our first workflow together.

Let's start off by covering some important core workflow concepts that you'll need to understand before building your own workflows.

Here we have the canvas. So from the canvas, we can see the main workflow elements. Up here, we have the workflow menu, the name and tags associated with that workflow.

We have the workflow activation settings. Here we can also access the version history and workflow specific settings up in the top right corner.

In the middle, obviously, we have the nodes of the given workflow, and we have some Zoom settings to the bottom left.

Activating the workflow is what allows us to push a workflow to production and is what actually allows us to start using the workflow automatically.

We'll cover workflow activation a little bit later in n8n. And of course, in the Cannabis, we have the nodes which are going to be the building blocks, the atoms of our workflow.

The main workflow menu is where you'll find all the workflows of your n8n instance. You'll find information like tags and owners that you can filter on.

Um, you can also find all workflows of which you are the creator by clicking my workflows down here to see only workflows owned by you. You can create a workflow, and every time you do, you are going to be assigned as the default owner.

From the workflow setting, so to the top right of the canvas, we can access everything that has to do with workflow accessibility, as well as the error workflow and how workflow executions are saved.

Um, we'll be covering both error workflows and saved executions in video number seven.

Let's look at how nodes are connected and how we actually can create workflows.

Every workflow starts with a trigger node. You can recognize them by the fact that they only have an output branch, as you can see here, and they have the orange lightning icon next to them.

A workflow can have multiple different triggers, multiple of the same trigger, or multiple different triggers for more complex use cases.

And the trigger is what starts the workflow, except when testing the workflow, it must be activated for the trigger to actually work.

In the canvas, when we double click on a node, we can see the nodes before and after the given node. Um, you can use these little icons to navigate through the workflow as you are building.

Here we have a very simple example. Uh, when clicking execute workflow, Google Sheets, filter, and then an edit Fields node.

And by double clicking the filter node, we can see to the left Google Sheets and to the right the edit filter node.

Another core topic we need to cover is branching. So branching is very important, uh, when building complex workflows. Um, branches are how we create different paths or different set of sets of actions depending on different conditions.

Um, branches is what allows us to create complex workflows where one workflow is able to cover a large variety of cases and not only one single case.

We can create branches in two different ways. The first way is we use a node that has multiple output options.

In this case, each item will follow only one of the multiple paths. So here, for example, we have, we have an if node, and the if node has two outputs, true and false.

As we can see, we have three input items and only one item goes through true and two items go through false, so each item only follows one specific path.

Another way to create branches is by dragging two or more output lines from a single node. This means every single item will follow every path and will be duplicated out by the number of paths.

We'll, um, see what this looks like in n8n in just a minute.

Nodes with multiple output branches will have different sets of output items, obviously. Um, and these can be accessed from the output data of the given node. For example, here the if node has an output item for items that satisfy the condition and an output item for items that don't satisfy the condition.

Let's jump into n8n and see what all of this looks like. So here we are back in n8n. Uh, the first thing I'd like to show you is, uh, triggers and activation.

So this workflow that we started building that we execute manually before reading some information in a Google sheet, if we want this workflow to execute, let's say every morning at 8:00 AM, we could use the schedule trigger, and this would allow us to set the, uh, trigger interval, how many days between each trigger and what hour to trigger at.

So in this case, we would like to trigger every day with, you know, every one, one day as spacing, and we're going to trigger it at 8:00 a.

m. Here you can see we have so multiple triggers on a given workflow.

And here, if I want to test the step, it is going to execute even though it is not 8:00 a.m. on a given day.

However, if I want to, uh, once I'm done building this workflow, if I want it to actually run every day at 8:00 AM, I have to make sure that the workflow is activated.

So when the workflow is activated, you will get a confirmation message. Your schedule trigger will now trigger executions on the schedule you have defined.

And now I could remove this, uh, manual step. Every time you activate a workflow, it will automatically save, um, so make sure that your uh workflow is ready to be activated before you actually do turn it on.

So continuing to build this workflow, let's add a node after the uh Google Sheets.

First, let's execute. So we have uh the data. Just as a reminder, we have here a list of contacts with their first name, last name, email, and company.

So what we'd like to do here is first of all, we'd like to remove everyone that doesn't have an email.

Let's say we want to email all of these people. If people do not have an email, then there's nothing we can do with them.

So we are going to use the filter node to filter out every contact that does not have an email.

So here in the filter node, we have our conditions and here we want to make sure that the email is, so email is going to be a string, a sequence of letters and characters, and we want to make sure that it exists.

So by executing this step, we can see that we went from 10 to 10 items in this case.

We can see that even if the email is empty, we still have an empty value. So in this case, the condition would not be exists, but rather is not equal to an empty string.

Here, if we test this step again, we will see that we go down from 10 items in the input to eight items that were kept and two items that were discarded, items that had empty emails.

So from here on, we only have the eight items uh that we want to work with that have emails.

From here we could think, okay, maybe we want a different kind of behavior depending depending on if the uh person has a professional email address or a work email address or a personal email address.

So here we can add an if node and in the if node we can add some conditions.

So looking at the JSON, we see here a Gmail address, some work emails, and a Hotmail address. So our condition here is going to be, we want the email to not contain gmail.

com. This will allow us to filter out the Gmail addresses, and as a second step, we could filter out.

So here we see we have gmail. and we have a hotmail.com. So by simplifying this condition by removing the .com, we could just remove anything that has @gmail, and we can add a condition.

When we add a condition, uh, and so we have two conditions in our if node, we have to decide how we want to combine the conditions.

Here we want to exclude everyone whose email contains @gmail or anyone whose email contains @Hotmail, and so in this case, we're going to be using the or filter.

So again, we drag and drop email, and we want it to not contain hotmail, or actually @Hotmail would be better.

If we test this step, so if we test this step, we can see that none of the items actually went into the false branch, and this is because we are creating the uh branch of professional email addresses, and so we actually should use the and condition.

The professional email addresses are that they don't contain Gmail and that they don't contain Hotmail. So here I can test this step.

Here we can see that we have uh multiple branches. So if I were to add a node here and then another one here and I execute again this if node, we're going to see five items are going up this branch and three items are going down this branch.

If we had, uh, this allows us to create these branches where each item of the input is going down only one of these paths if we were to uh just drag another if from the filter node and then maybe just realign things so we can see a bit better.

And here I execute the filter node, we can see that in this case, eight items are going down here and eight items are going down here. So by dragging multiple outputs from the same node, we duplicate the items down both paths, but by creating an if or a set of conditional branches, then we split the items down the different paths.

Thanks for listening to the fifth video of the n8n beginner course where we covered some core workflow concepts and created our first connected nodes.

In the next video, we'll be covering some very useful nodes when building workflows and we'll keep on building on this workflow to make a more complex example.

n8n Beginner Course (5/9) - Core workflow concepts

Scripts