"Tasks" is a feature that allows human interaction inside workflows. Any flow that requires non-automated approval can be easily built using this powerful module.

To understand how this module works, let's dive straight into a simple example.

Say we wanted to approve documents once they enter a specific folder in our Google Drive. Documents get manually or automatically sent to a specific folder which triggers a flow in Appmixer. This flow makes sure a relevant person gets notified and is incentivised to approve or reject the document. After the approval or rejection, the document is automatically sent either to the "Approved" or "Rejected" folder. A process that would be somewhat time-consuming is now a question of a single click.

Before we uncover all the steps required to build such a flow, let's start from the end and see what the flow looks like in Appmixer when it's complete.

Let's see how we've built the flow from scratch. First, we need to set up the trigger. In this case, the flow starts every time a new file gets uploaded to the "Waiting for approval" folder in our G-Drive.

We want to notify the approver via email. Therefore, we need to use the "RequestApprovalEmail" component under the "Tasks" module. As said earlier, this module makes sure the relevant person receives an email where she can easily approve or reject the document. First, we set the Task title and Description.

Next, we need to define the Requester and Approver emails.

Last but not least, we need to set the "Decision by" date. Here, we will use Modifiers and will set the due date to the time the document was created + 24 hours. In other words, the approver has 24 hours to approve the document after it's been uploaded to the "Waiting for approval" folder.

Notice there are three paths from the Tasks component: approved, rejected, and due. As the names suggest, "approved" sets the path once the document gets approved, "rejected" allows you to set a different path in case the document gets rejected, and "due" helps you adjust the flow when the task is due. In our case, we want to notify the approver via SMS.

When the document gets approved, we need to export the relevant file from our G-Drive and upload it to the relevant folder.

Also, we want to send a Slack message every time a document gets approved.

Notice how we've used Variables throughout the setup. Thus, we will make sure the flow works with the right file throughout the execution, and we get a notification on Slack with a better context (using the file name and web link in the message body).

Now when the "Approved" path is set, let's finalise the "Rejected" path. To save you a little bit of time, see the already set up path below. Needless to say, the process for similar to setting up the "Approved" path.

As stated above, we want to notify the approver via SMS when the task is due. This way, we reduce the risk of tasks being forgotten.

We're all set now. When we start the flow, upload a file to the "Waiting for approval" folder and the file gets approved or rejected, we should see in the Logs that the flow runs successfully.

You may wonder, how does the approver approve or reject the documents? Glad you ask. In this case, the approver can either hit the "Approve" or "Reject" button in an email that is sent as part of the "RequestApprovalEmail" component...

... or she can visit the "Tasks" dashboard where she sees all the tasks.

As you can see, instead of logging into a G-Drive account, finding the right folder, opening a document, and then moving it into the right folder (Approved or Rejected), the approver hits a single button and Appmixer takes care of the rest. Simple, yet very powerful.

You may have noticed the other component under the "Tasks" module called "RequestApproval". This component works similarly to RequestApprovalEmail, but it allows you to set a specific path also when the task is created. For example, you may want to create a task in Asana. In this case, no email is sent. Instead of that, you use the links for approval/rejection and pass it to Asana (or any other platform).

Great job! You went through a pretty extensive example of how Tasks can be used. Next, we'll look at another great module, Language.

When building a flow in the Appmixer Studio, there are Utilities and Applications in the left panel (note that these categories are completely configurable and thus can have different naming in your own Appmixer installation). These are the components that help you build a flow. In a single flow, you can use an unlimited number of components and, thus, automate any process you like.

In this section, we will explain some of the core Utility modules that are at your disposal by default. Keep in mind that you can customise all components and also implement your own using NodeJS and upload them to the Appmixer engine via the API to suit your specific business needs.

As you probably know, Webhooks are one way that apps can send automated messages or information to other apps.

Let's look at a simple example presented by Zapier: "Webhooks are much like SMS notifications. Say your bank sends you an SMS when you make a new purchase. You already told the bank your phone number, so they knew where to send the message. They type out "You just spent $10 at NewStore" and send it to your phone number +1-234-567-8900. Something happened at your bank, and you got a message about it. All is well. Webhooks work the same way."

Makes sense? Great! Let's see how you can use Webhooks inside Appmixer.

Let's look at another example. Say we want to create a task in Asana every time a high-priority contact visits our website. The idea is to notify our sales reps about the user's activity, and empower them to engage with potential customers at the right time.

In this case, we use ActiveCampaign to catch the user's website activity and send a message to Webhook using ActiveCampaign workflow automation designer. The Webhook URL is automatically generated by Appmixer and is available to you in the inspector panel as soon as you use a Webhook component in your flow.

To bring our example to life, let's start by placing the components to the canvas.

Next, we will want to use the generated Webhook URL in the ActiveCampaign automation.

Notice that the automation trigger in ActiveCampaign listens for a website visit and – if the contact has a "Score: Overall" more than 100 – sends the data to the Webhook URL. This has nothing to do with how the automation in Appmixer is set up, rather gives you a full context on how the whole flow works.

Next, we'll want to connect the components in the Appmixer's flow.

Notice that there are fields to be set up in the Asana action. Let's make it a little bit easier for our sales reps and send some of the contact details directly to the Asana task name and description. This way, our sales reps will immediately know who to follow up with.

First, use Modifiers to set up the task name to: "Follow up with {contact's name}".

Second, let's add some more context to the task description using the person's email address and ActiveCampaign ID.

Once we start the flows both in ActiveCampaign and Appmixer, we should start seeing new tasks in Asana once a person with more than or equal to 100 points – based on our lead scoring system – visits the website.

The idea of our flow was to notify sales reps when a high-score contact visits a website. As you can see below, we now create a task in Asana every time a contact that meets our criteria visits a website. Work done ✅

As you can see, Webhooks are a very powerful feature that gives you all you need to make different apps talk to each other. You can also use Webhooks to build your own, tiny web servers, visually in Appmixer. And yes, you don't necessarily need to be a developer to do that.

Playing around with Webhooks, you may encounter some terms that may be new to you. We've listed all that may surprise you in Appmixer below.

Now that you know how to use Webhooks in Appmixer, let's uncover some of the other core Utility Modules. In the next section, we'll stay in the "HTTP" module, and explain how some of the most common HTTP requests like POST, PUT, or DELETE work.

Some clever person once said that repetition is the key to mastery. Let's, therefore, once again uncover the strength of another Utility module. This time, we'll talk about Filters.

As outlined above, Filters represent an effective way to implement logic into your flows. Just drag & drop the Filters utility module to see all the options that are there for you to discover.

As you can see, there are multiple components that help you incorporate some decision-making processes into your flows. Let's explain all of them.

To fully understand Filters, we recommend looking at an example that we presented in one of the previous sections.

. In this section, we'll show you a simple yet effective way to implement Scheduling features into your flows.

Imagine we want to get a daily notification based on the current weather. In the flow below, we look at cloudiness and, based on the current weather, send either a "Cloudy" or "Sunny" email.

Notice how we've used the "Timer" component (named "Every day" and located at the beginning of the flow) to run the flow every 24 hours (1440 minutes).

You may have noticed, we used the "Timers" module that consist of three components: Scheduler, Timer and Wait.

Here is a simple explanation of each of the "Timers" components.

You recently learned about the Scheduling feature, now it's time to dig deeper into Forms.

Forms represent a great feature that helps you collect data and use it further in your flow. Say you organise an event and want participants to fill out a simple flow that gathers all the data you need for further usage like sending reminders, creating an attendee list, etc. Appmixer helps you create a form and collect the data with ease.

Let's see how such a flow could be built in Appmixer.

In the example above, we created a form that is accessible in the "Form URL" and containing four fields: First Name, Last Name, Email, and Phone Number. Once the form gets filled out, a new contact is created in ActiveCampaign, and a Slack notification is sent.

Below, see what the Appmixer form looks like by default. Of course, you can fully customise it to your liking.

In the scenario above, we've used the "FormTrigger" component. This component gives you a URL that you can send via other channels to other people and every time they submit the form, the "FormTrigger" component in your flow triggers with the form submission data.

Alternatively, you can use the "FormAction" component and use a more complicated logic that creates a form every time a different trigger fires and get the form URL dynamically so that you can. e.g. send the form URL via SMS.

Let's continue with our example. Say we want to send a unique link in an email campaign that will motivate attendees to invite their friends or colleagues. We want to create a unique Form URL, pass it over to ActiveCampaign as a custom field (to use it in the email campaign), and create a new contact in ActiveCampaign every time the dynamically created form gets filled out.

This is how it would look in the Appmixer Studio.

As you can see, there are two output ports in the "FormAction" component: form and entry. The "form" output port passes the dynamically created Form URL to ActiveCampaign (updates a contact), entry collects the data once the dynamically created form gets filled out and sends it to ActiveCampaign (creates a new contact).

This is, of course, just one simple example of how Forms can serve your business needs. The scenarios and business cases you could solve with Forms are limitless.

Let's wrap it up with terminology you may need to understand to fully leverage the potential of Forms in Appmixer.

We haven't touched the customising and styling of the form yet. Needless to say, you can fully customise the flow to your liking, either by adjusting the form title, description, form fields, call to action text, thank you message, or by implementing advanced styling options like Scripts and Stylesheets.

All in all, Forms can be a great helper if you want to collect data and use it further in your flow. Next, we'll look at another Utility Module, Tasks.

In the last section, we explained how Webhooks work. In this section, you'll learn about other components that come under the HTTP module in Appmixer. Namely, we'll talk about some of the most common HTTP requests like POST, PUT, GET, RESPONSE, UPTIME or DELETE.

To start using HTTP requests in Appmixer, drag the "HTTP" module from the left panel and drop it to the canvas.

Note that there are multiple requests you can send using Appmixer.

Let's look at an example where the GET method is used. Say we wanted to get the current Bitcoin price (USD) to our email every day at 10 AM. Knowing there are open APIs that allow us to get the current Bitcoin price, the setup in Appmixer will already be pretty simple.

We'll start the flow with the Scheduling module that will be presented later in the Knowledge Base. For now, let's just say this trigger makes sure the flow starts every day at 10 AM.

Next, we want to use the HTTP module or, more specifically, the GET component. We need to define the Host URL from which we'll gather the data. In this example, we use this Host URL to get the current Bitcoin price: https://min-api.cryptocompare.com/data/price?fsym=BTC&tsyms=USD

Almost done! The last piece of the puzzle is the "SendEmail" component that will ensure we get notified via email when the flow executes. Let's set the email address, subject, and as the body of the email, we may want to use the current Bitcoin price. Notice how we use both Variables and Modifiers to extract the data we need.

It's important to note that the way you alter the data using Modifiers depends on the response you get when calling the API. In our case, we set the JSON path to "USD".

Once we hit the "Start Flow" button, miracles happen... Well, maybe not miracles, but we certainly get the current Bitcoin price sent to our email address.

Now that you know how to use HTTP requests, let's look at another powerful Utility module, Filters.

Let us introduce you to one of the features (not only) international teams love! ❤️ Yes, the "Language" module with some pretty neat components like translating, analysing the sentiment, or detecting the language is what we have in mind.

We worked pretty hard on this one to empower you with some cool language-based features. As outlined earlier, there are three main components under the "Language" module:

• Analyse the sentiment

• Detect the language

• Translate

Let's look at an example using the "Analyse the sentiment" component. Today, brands don't fully control the way they are perceived. More than ever, (potential) customers shape the way our brand is sensed.

Having said that, let's imagine we want to listen for mentions on Twitter (when someone mentions our brand) and analyse the sentiment of the message. If the calculated score of the sentiment is lower than a certain limit (zero in this case), we want to get notified on Slack. This way, we make sure no Tweet that puts our brand in a bad light gets forgotten and unanswered. To celebrate positive brand mentions with the team, let's send a Slack message every time a positive mention is Tweeted.

Below, see what the complete flow looks like in Appmixer.

Makes sense? Great, let's uncover the other two components: detect the language and translate.

Say your customer support gets requests in many languages of which some are not supported. Imagine you'd want to detect the language of the ticket and send it to a Google Sheet for statistical purposes. Below, see such an example using Freshdesk component that listens for new tickets.

As a result, we will be able to detect the language and make decisions based on the outcome. Now, let's extend the current flow and translate the request to English using the third component: translate. Besides that, we may want to update the ticket using the translated text to keep things organised for our customer support.

God damn, that feels good! 😎We just eased our customer support of some boring manual work.

Before we call it a day, let's answer some of the questions related to the "Language" module.

In the next section, we'll learn how accounts work in Appmixer.