SDK Demo is here as an example of how you can embed Appmixer into your product. As you already know, Appmixer is not an end-user product. Being seamlessly embedded into your platform, Appmixer becomes a natural part of your product without your end-users noticing.

The SDK Demo and especially its source code is very useful as an example of how to use the Appmixer JavaScript SDK to display e.g. the drag&drop workflow automation designer, connected accounts, flow manager, and logs in your product. Moreover, it shows you how you can associate your user management system with Appmixer virtual users.

Use SDK Demo to:

• study the source code in order to understand how to embed Appmixer in your product using the Appmixer JavaScript SDK

• preview what Appmixer looks like in your platform and, thus, reveal the experience your end-users have when interacting with Appmixer's interfaces.

Further in the Knowledge Base, you'll find out there are two SDK Demos:

1. Workflow automation helping you preview the interface in which you or your end-users build sophisticated flows from scratch.

2. Integration templates empowering your end-users with a simplistic way to integrate different apps.

Access both SDK Demos below.

Welcome to the Appmixer Knowledge Base! 👋

In the following sections, you'll get a clear picture of what Appmixer is and how this technology helps you implement automation and integration capabilities into your platform.

Throughout the Knowledge Base, you will come across three main interfaces: Studio, Backoffice, and SDK Demo (which is not a final interface but serves as a guide for your developers to understand how to integrate the Appmixer UIs into your own product). To understand how Appmixer works, it is crucial to understand the difference between them. Refer to the sections below to understand the basics.

Once all the basics are clear, start exploring the key features of all of the three interfaces. There is so much to discover in Appmixer. Thanks to the fact that Appmixer can be fully customised to suit your business needs, you can extend the limits and make Appmixer even more powerful.

Appmixer Studio is the interface where the flow configuration happens. As you already know, this interface can be used to build flows for internal processes, integration templates that will be exposed to your less technical end-users via simple integration wizards, or can be embedded into your platform to empower your end-users to build sophisticated workflows.

Besides that, Appmixer Studio helps you connect and manage your accounts (connection to third-party apps), create, edit and manage Data storage, and access insights that help you control the performance of your flows.

Use Appmixer Studio to:

• create and manage your flows and integration templates,

• connect and manage your accounts (connections with third-party apps),

• create, edit and manage data storage,

• access insights (dashboard, logs) to find out how flows are performing.

We dedicated a whole section to Appmixer Studio features. Learn more about them by reading the section below.

Think of Backoffice as your admin panel. Our customers use it mainly to register third-party apps (using API keys), manage users, user scopes and their rights, and see all flows created in their Appmixer instance.

Use Backoffice to:

• view high-level insights (monthly message volume and message size),

• access all flows created in your Appmixer instance,

• manage users, user scopes and their rights,

• register third-party apps (Slack, Salesforce etc.).

Learn about the core features of the Appmixer Backoffice:

Appmixer is a white-labeled embedded iPaaS (Integration Platform as a Service) with a workflow automation engine and no-code workflow tool that can be embedded inside any SaaS product.

The key features of Appmixer are:

• Integration platform: Appmixer takes care of the heavy lifting associated with developing API integrations. Built-in support for Authentication (OAuth 1, OAuth 2, API keys), automatic handling of API quotas and limits, graceful error handling and recovery, log history with dashboards and charts, and much more.

• Workflow Automation Engine: Scalable workflow automation engine with REST API automates business processes and data flows.

• No-code workflow automation builder: An embeddable drag&drop workflow designer UI.

• JavaScript SDK: JavaScript SDK seamlessly embeds any of Appmixer UI widgets — including the drag-and-drop workflow designer — into your web product. All UI widgets are fully customisable.

• Custom Connectors: Appmixer is equipped with over 100 ready-to-use connectors for the most popular platforms, or you can build your own custom triggers, actions, and Webhooks to any third-party cloud app or internal API.

There are two use cases for which Appmixer can do an exceptional job:

• embedding Appmixer into your software and exposing the Appmixer Studio to your end-users to allow them to build complex workflows, or using the Studio to build internal flows,

• creating and managing integration templates and exposing only the simplistic integration wizards to less technical end-users.

Let's look at both use cases in better detail.

1. Building sophisticated flows in the Appmixer Studio

As stated above, you can expose the Appmixer Studio to your end-users and empower them with endless integration and automation possibilities, or use the Studio to build flows for internal purposes. In both cases, the sky is the limit in terms of flow complexity.

Below, see an example flow built in the Appmixer Studio.

2. Creating and managing integration templates

Not all users are tech-savvy and have the skills to build complex flows. For these cases, all you can do is to prebuilt so-called integration wizards, and let your end-users fill in only the last missing details.

Below, see an example of an Integration template that syncs contacts to Salesforce. As you can see, instead of letting your end-user configure the flow in the Studio, you can predefine the fields that need to be filled out, and let the end-user use the simplistic version aka Integration wizard.

As you can see, Appmixer is very flexible. There are literally no limits in how you can use Appmixer both for your internal purposes, or to upgrade your software and allow your end-users to automate processes and integrate with third-party platforms.

Now that you have a better idea of how Appmixer works, let's uncover the three main interfaces: Appmixer Studio, Backoffice, and SDK Demo.

As outlined in the previous section, Appmixer consists of three main interfaces: Appmixer Studio, Backoffice, and SDK Demo.

• Appmixer Studio is the environment where the flow configuration happens, Besides flow creation, you can manage your connected accounts, troubleshoot errors, view insights and set up custom key-value data stores.

• Backoffice, being the most technical part of Appmixer, serves similarly like an admin panel. Here, you can grant access to other users, manage access control lists, register third-party apps etc.

• SDK Demo helps you preview what your end-users see and interact with. As you already know, Appmixer is an embedded (white-label) solution that lives inside your software. The SDK Demo serves as an inspiration for your developers on how they can use the Appmixer JavaScript SDK to embed Appmixer in your product.

Let's explore all the interfaces one by one.

Now that you know what Appmixer is and how all its interfaces work, we'd love you to meet flows. Flows are the core of Appmixer offering you all you need to build an application without writing a single line of code, automate internal or external processes, and ultimately, build a scalable platform that delights your customers.

A flow represents a business process that reacts to events, transforms incoming data, makes decisions, performs actions, stores data and/or loads data to external systems. Flows can be designed in the Appmixer drag&drop visual Flow designer or created through the Appmixer API.

For example, a flow can represent a process that waits for new incoming calls, asks for the user requirement, and based on the result, forwards the call to a relevant department.

Like it? Great! Let's learn how to create your first flow.

As outlined in the previous section, a flow represents a business process that reacts to events, transforms incoming data, makes decisions, performs actions, stores data, and/or loads data to external systems. The way you create a flow is pretty straightforward.

Before you start creating a flow, we recommend having a specific business logic or a use case in mind. This way, you'll be able to easily choose between different utilities and applications and create a meaningful flow.

Once you're ready, visit the visual drag&drop designer and choose the utility or application from the left panel. Drag the so-called component and drop it to the blank canvas. Thus, you'll start building your business logic.

Notice that once you drop the component to the canvas, a panel on the left shows up. Here, you need to choose the trigger or action.

You can use an unlimited number of components in a single flow and, thus, build complex business logic for internal or external use cases.

After you've finalised the setup, make sure to click the "Start Flow" button to activate the flow. Otherwise, the flow remains inactive.

In the next section, you'll learn how to share a flow.

Did you know that you can share a flow with your colleagues? No? Well, let's jump straight into this cool feature. , you're now ready to share the flow with your workmates.

To share a flow, open the flow and click on the arrow icon next to the "Start Flow" button.

By clicking on "Share", a modal opens up offering you multiple ways to share the flow.

Let's briefly go through all of them:

• Email: Share a flow with your colleague by typing his/her email address.

• Scope: Share a flow with a scope of users that you previously defined in the Backoffice (e.g. IT Department).

• Domain: Share a flow with anyone signing in with an email that contains the inserted domain. E.g. by typing "appmixer.com", anyone with an email ending @appmixer.com will see the flow in their account.

Note that you can set the rights when sharing a flow. Currently, we support "Read", "Start" and "Stop" actions:

• Read: The user with whom you share the flow will only be able to see the flow setup.

• Start: The user with whom you share the flow will be able to start the flow.

• Stop: The user with whom you share the flow will be able to stop the flow.

Where do all the shared flows live, you may ask. You can see all your previously created flows in the flow panel. When someone shares a flow with you, you will see it here.

By now, you should already know , how you can and . As we already said, the sky is the limit in terms of flow complexity. Being able to use an unlimited number of components in a single flow, there is probably no business process that can not be designed and automated in Appmixer.

Let's go through some examples of how flows can be used, and most importantly, how they can help you automate processes and sync data between different platforms.

In this example, we demonstrate how to forward customer support calls – or calls in general – to customer service, but only if the PIN provided by the user is known.

Twilio is a good voice & SMS API that we take advantage of. An alternative would be to use Plivo which is provided as a built-in app in Appmixer too. Of course, you can use any other tool of your preference (provided the component exists or you build it yourself).

In this example, we will use two apps: Twilio and Google Sheet. Below, see an overview of our flow.

We start with a trigger component that is activated when a call is received on our Twilio number.

As soon as a call is received, we want to ask the user for their PIN code. We can use the GatherCallInput Twilio component to do that. Let's fill in the message and enter parameters of our PINs – number of digits and finish key.

Next, we want to match the user input with values in our database using the Google Sheet component. In other words, this component helps us check whether the PIN already exists in our database or not.

As you can see, there are two paths from the Google Sheet component: out and notFound. We want to set different scenarios for both of these. Let's start with the case where we found the PIN in our database.

The initial goal of this flow was to forward the call to customer services, remember? Now it's the right time to set the ForwardCall component.

If we don't find the PIN in our database, we want to answer the user pointing out we haven't found her PIN, and that her next steps should be to get in touch with our sales department.

Done ✅ We can start the flow now, and make the first step to streamline our customer support processes.

A lot of 3rd party apps provide real-time notifications with Webhooks, i.e. they call a registered URL with data every time a certain event occurs. How do you easily store this data as e.g. new contacts in your marketing automation software or a CRM tho? This example flow shows you a simple yet effective way.

Before we jump into how the flow has been set up, see the flow overview below.

As you can see, we're expecting HTTP requests to our Webhook component and feed the incoming data like new subscribers to our Mailchimp account.

The Webhook component gives you a URL that you can copy-paste to your 3rd party app. Here is how to get started.

Whenever the Webhook URL is called by the 3rd party app, we want to create a new subscriber in our Mailchimp list with the email address received from the Webhook. Here is how to set it up in our flow.

Notice we selected the "data" variable in the "Email" field. This variable is coming from our Webhook component.

To set up the flow properly, you need a certain knowledge of the data structure that the 3rd party app sends to the Webhook. Browse through the documentation of the 3rd party app to find out.

In our case, the Webhook receives a JSON object with an "email" field. Therefore, we need to extract that email field from the incoming JSON data. By clicking on the Variable, we bring up the Modifier's dialog.

Notice we've selected the "JSON path" modifier and type "email" into the "Path" field.

All that remains is to start the flow and we're all set! Our Mailchimp list will now receive a new subscriber whenever our Webhook is called. 👍

As a bonus, we can also send the subscriber to our Slack channel for everyone to get excited about our newly registered users.

Now that you know how to feed customer data to Mailchimp and notify your team, it's time to look at our last flow example. This time, we will set up a pretty sophisticated flow that helps us approve documents more efficiently.

We might have already mentioned that creating Integration templates, or empowering your end-users with a simplistic way to create flows using wizards, is one of the core features of Appmixer. Not everyone is tech-savvy and wants to build flows from scratch. If this is the case, Integration templates are here to save the day.

Integration templates need to be first created by you or anyone from your team. For that, you'd use the Appmixer Studio as you know it. Only then you can turn your flow into a template.

Say you created a flow that listens to survey fill-outs in Typeform and adds a new subscriber in Mailchimp. Instead of letting your users build the whole flow from scratch, you can build the flow yourself and make it a reusable template. Below, see an example of a few templates.

First things first. To be able to create an integration template, you need to turn on the developer mode. Visit your profile in the Appmixer Studio, and turn on the "Developer Mode" toggle.

Go back to a flow from which you'd like to create a template and click on the arrow icon next to the "Start Flow" button.

See the "Wizard Builder" option? That's exactly what we need. Note that without previously activating the Developer Mode, you won't see this option in the dropdown menu.

Once you click on it, the Wizard Builder opens up. Here, you can define the fields that the end-user has to configure when starting her flow from the template.

In our example, the user will be able to authenticate her Typeform and Mailchimp accounts, choose the form, list to which the subscriber will be sent, email being the mandatory field when creating a new subscriber in Mailchimp, and status.

That's it. You're all set. Curious about how it looks when the user uses the template? Great, let's dive in.

As said, Integration templates help even non-technical users to automate workflows and integrate different apps without any previous experience with building flows or (God forgive) coding.

In the next section, we will look at Variables and how they help map data between different apps.

In this example, we will set up a flow that watches for new documents in our Google Drive “Before Approval” folder. Each new document added to the folder generates a new human task for a manager to manually approve the document. This task will be sent to the manager’s email address as an email with two buttons – "Approve" and "Reject" – together with a link to the document.

Once the manager approves it, the document will be copied to the Google Drive “Approved” folder. If the manager rejects the document, it will be copied to the “Rejected” Google Drive folder. At the same time, a Slack notification is sent to a channel with the resolution.

Seems like a lot of work? Not with Appmixer. Let's get started!

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 he or 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.

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.

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

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.

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 he 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.

Our flow is configured to trigger as soon as the flow is started, imports a CSV file that we uploaded via the file upload interface of the CSV.ImportCSV utility, gets all the rows, calculate an average age of the persons in the CSV and sends the result via email. Our flow looks like this:

The ImportCSV utility from the CSV module is simply configured to read a file that we selected from our file system by clicking on the "Select file" input field:

The content of our CSV sample file looks like this:

name,age
John,35
Jane,27
Peter,54

The configuration for the GetRows component uses the fileId variable from the ImportCSV component for the "File ID" input field. We also disabled the "Filter rows" parameter since we're interested in getting all the rows from the CSV file, not just an extracted subset. Also note that the "Row format" is set to "Object" so that the component gives us a formatted JSON list of all the rows in the form [{col1: val1, col2: val2}, ...].

Next, we configure the final SendEmail component to send an email with the average age. The trick here is to calculate the average age by modifying the rows variable returned from GetRows component.

By clicking on the rows variable, we can configure our modifiers (data transformation functions) that calculate the average by first calculating the sum of all ages and dividing it by the number of items in the rows list:

Note that the modifiers can be stacked to produce more complex expressions. In the example above, we first "Pick" the age column only, apply "Sum" to the values and "Div" by the length of the rows list. Note that the length of the rows is defined by applying the nested "Length" modifier which we can do by clicking on the rows variable in the "Div" input field:

This is it! Now when we actually run our flow, we'll see a new email in our inbox with the average age of all the persons in our CSV file:

As a bonus for advanced users, we can also use a "low-code" alternative to our modifiers above by defining a JavaScript function modifier that will give us an average of values in our age column:

As you can see, the "JavaScript Function" modifier takes an arbitrary JavaScript code in which you can refer to the original variable with the $variable placeholder.

You learned that Variables are placeholders for data coming from previously connected components in your flows that will be eventually replaced with real values once they are available at flow runtime.

Sometimes you need to modify the values. For example, you receive a percentage value but you'd like to store it in the decimal format (i.e. 75 becomes 0.75). This is exactly where Modifiers excel.

Modifiers are a powerful tool to modify variable values, change their format or even use conditionals and loops to structure the actual output of your variables. It's like applying excel formulas to your variables - but simpler.

Modifiers can be stacked, meaning that the result of one modifier is an input to another modifier used for the same variable (e.g. "divide by 10, then add 50, then round").

Let's dig deeper into what Modifiers are by continuing with our simple example. Say we collect a "Percentage" field in a form and pass the data to a Google Sheet. On the way, we want to adjust the percentage from 75 to 0.75. To achieve that, you can simply click on the variable and choose the right data modifier.

As you can see, the Modifiers dialog contains different categories for different types of variable values. In our case, we're interested in the "Number" category and the "Div" modifier that divides our Percent variable by another number that we specify. Just click the "Div" modifier to apply it to our variable and tell the modifier that we want to modify our value by 100.

Now press "Close" and you'll see the "Percent" variable changed appearance a little bit to tell you that it will be modified at runtime.

To explain the power of modifiers, let's look at the second example. This time, we'll want to modify dates. Imagine we keep a record of our employees' vacations and want to notify them by email and SMS two days before their vacation ends to remind them that they should come to work in two days. Our sheet can look like this:

Our "To Date" column contains the end date of the employee's vacation. However, we want to send them SMS and email two days before their first day at work. Therefore, we want to subtract one day from the "To Date" and wait for that new date to send them reminders. Our flow can look like this.

Notice how we use the "Wait" component to wait for a certain date. In the "Until" field, we use the modified "To Date" column value. We modified our variable with the "AddSpan" modifier from the "Date" category and filled "-1" for the "Days" parameter.

You might have noticed that there are many modifier categories and types at your disposal. We intend to give you maximal flexibility with our pre-built modifiers or empower you to simply build your categories and types.

Below, see the complete list of Modifier categories and types.

In the next section, you'll learn how to implement logic to your flows.

In the previous section, you learned how to create Integration templates using the Wizard Builder feature. Now, it's time to map data between different components using Variables.

Variables are placeholders for data that will be only known at flow runtime. They let you use data from one component in other - connected - components.

For example, a component that triggers with new messages in a private Slack channel passes data to a component that sends SMS for each new message. In the SMS text, the original Slack message is passed using Variables.

Notice that we've used the Variables picker on the right to show available variables. This icon and, most importantly, the variable feature is available to you any time you create a flow. Thus, you can map data between any pre-built apps and utilities, or any other component that you build yourself.

Now that you know how to use variables to map data between different components, let's see how you can alter the data using Modifiers.

In the previous section, you learned about the power of Modifiers and their ability to alter data in your flow. Now, we'll go through another powerful feature of Appmixer, logic.

Logic is represented mainly by the "Filters" component that you can find among Utilities. This feature allows you to set certain rules in your flow.

To see the logic in action, let's look at a simple example. Imagine you want to get notified via SMS every time someone mentions the word "Urgent" in a Slack channel. We're humans and we forget. This simple flow will make sure you receive the message when there's a fire.

You'd start building your flow by adding Slack and Twilio (or any other provider) components.

In between them, you'll want to add "Filters" and apply the "Contains" logic.

Now, it's time to set the logic. You'll want to use a Variable to check if the Slack message contains the word "Urgent".

Finally, choose the "contains" path and connect it to Twilio. After you do that, you'll be able to finalise the flow by setting the text message, "From number" and "To number". Let's say we want to use the whole Slack message as the SMS text. To do that, you'll use Variables that we explained in the previous section.

Awesome, isn't it? Keep in mind that "Contains" is just one of the logic options you can use. Here's the rest:

You've just learned how to implement logic into your flow. In the next section, you'll find out how to view logs and troubleshoot errors.

. In this section, we'll show you another great designer feature, zooming in/out.

We've already mentioned that you can use an unlimited number of components in a single flow, right? Some of our customers (or their customers) build flows containing hundreds of components. Believe us, a feature to zoom in/out comes in handy in these cases.

To zoom out, click the little Zoom out icon in the bottom panel.

To zoom in, click on the Zoom in icon in the bottom panel.

In the previous section, you learned how to select multiple objects and, thus, save time while adjusting and organising complex flows. Now, you'll learn how to copy & paste objects to boost your performance even more.

For anyone who's used a computer in the past 20 years, the instructions will be pretty easy to understand: ⌘ Cmd + C to copy an object, ⌘ Cmd + V to paste an object.

We see you laughing! Well, you will be thankful once you start building a complex flow and will start saving time copying & pasting the objects in the designer. At least, that's what we hope for. 🙂

In the previous sections, you learned about the basics of Appmixer. Now, it's the right time to present some of the core visual features of the Appmixer Studio.

One of the key features is selecting multiple objects. Building a visual flow often means putting a very complex business logic on a piece of "digital paper". This logic has to be functional but also organised and well documented. When moving components and adjusting the visual feel of your flows, the ability to select multiple objects can be a huge time saver.

The way you select multiple objects is pretty straightforward. Hold ⇧ Shift and click on the desired components.

Alternatively, you can select multiple objects by holding ⇧ Shift and choosing the objects in bulk.

Now, you can start moving the selected components to add more space to your flow or reorganise the flow in any way you desire.

When building a flow, you may have noticed some visual features that help you work more efficiently. In this section, we will go through all of them one by one.

. Now, supposing that you've already created a flow, you'll learn a simple way to export a flow to an image.

To export a flow to an image, click on the arrow icon next to the "Start Flow" button.

As you can see, there are two options. You can export the flow as a PNG or SVG. The following process is the same for both of these formats. Right-click the image and download the image.

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.

In the last section, we spoke about the importance of a clear naming convention. Now that you know how to rename a flow, let's look at a simple way to rename a component. That's right, even the pre-built components can be renamed so that your flow is clear to you or/and your colleagues even after months from the launch.

Start by opening a flow and clicking on the component that you want to rename.

Do you see the "pen" icon on the right? Nice! Click it... Now, you can insert a new name of the component and, thus, keep your flow organised for yourself and/or your colleagues.

Congrats! 🎉 You learned about all the core visual features of the Appmixer Studio. Next, you'll learn about the power of Utility modules.

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.

A naming convention is important. A naming convention is important. A naming con... We just can't stress that enough. It indeed is important to keep your account organised. Your future yourself or your colleagues will thank you for that.

Knowing that you've learned some of the key features of the Appmixer Studio like exporting flow to an image, now it's the right time to learn how to rename a flow.

Open the flow and click on the "pen" icon next to the current flow name.

Now, insert the new name of the flow and click "Rename".

That's it! As simple as it looks, having a clear naming convention is helpful. Next, we'll show you how to change a name of a component.

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.

Didn't we already mention you can implement logic in your flows? 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.

Next, we'll look at another Utility module, Scheduling.

"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.

Previously, you learned about the power of Webhooks and HTTP requests. 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.

Having learned the basics about the Scheduling feature, let's look at another great tool, Forms.

Take Asana as an example. If you decide to use Asana in your flows, you need to make sure your account is successfully connected to Appmixer. Once you do that, you'll have all you need to start using triggers like listening for new comments, or actions like creating new tasks.

The way to connect a new account to Appmixer is pretty straightforward. Navigate to a flow where the newly connected component will be used, drag and drop the component to a canvas, and choose the trigger or action.

You'll notice your account is not connected yet.

To connect your account successfully, click on the "Connect new account" icon and wait for the authentication process to start.

⚠️ The prerequisite here is that your developers registered the desired apps with Appmixer so that you or your end-users can complete the authentication process seeing your company details like logo and company name. Without that, the process above won't work.

Once the authentication is successfully finished, you have all you need to start using the newly connected component in your flows.

You might be wondering if there is centralised place where you can manage your connected accounts. The answer is yes! Read our next section to find out how to rename, test or disconnect your accounts.

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.

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.

As you already know, Appmixer allows you to implement logic that makes your flows smarter, but also more complicated. In both cases, you probably won't avoid errors. Luckily, we got you covered with a feature called "Logs" that allows you to see the past flow runtime and detect the bottlenecks of your flows.

"Logs" is a powerful feature that helps you investigate the details of past flow runtimes and troubleshoot errors. There are multiple ways to view Logs.

1. View Logs in a flow

To view Logs in a flow, open the flow and click on the little icon in the panel below.

2. View Logs in Insights

Alternatively, you can use our Insights features and view Logs there.

You can, of course, view the log detail. Simply click on the log you'd like to check in better detail and wait for the window to show up.

Viewing Logs may be pretty simple once you know where to click. There is, nonetheless, some terminology that remains to be explained.

Logs is a great feature that allows you to double-check if you've set up your flow correctly. Should you encounter errors, logs help you identify the problematic points.

Next, you'll learn about some of the visual features that help you work more efficiently. Stay tuned. 😎

Throughout the process of creating workflow automations or integrations, you will be most likely connecting different third-party accounts (Slack, Asana, Salesforce, ...). The time and place you'll be connecting the accounts is at the time you need them, in the flow/integration configurations. However, it is very useful to have a one-stop shop for all your third-party accounts for management and security purposes. This is exactly what the Connected Account UI provides.

In the following sections, you'll learn how to connect a new account and manage it in the "Accounts" panel.

. Now, we'll show you how to manage your accounts. There are a couple of things you can do with your accounts:

• test the connection,

• rename the connection,

• see the flows where the connection is used,

• revoke the connection.

Have you noticed the Accounts tab in the designer? Great! That's where all your connected accounts live.

From here, you can do all the actions stated above. Even though we've designed the UI to guide you, let's go through all the actions one by one.

Test your connection

Your flows depend on a successfully connected account. At least the ones using integrations with third-party platforms. One way to see if all connections are running like butter is to test them, either using the bulk action or testing them one by one.

"Tested" means there is nothing stopping you from using your connection. "Failed", on the other hand, requires your attention or attention of your developers.

Rename the connection

The default names of your connections may be a little bit messy. You can easily rename them to keep your account organised and clear for you and your colleagues.

See the flows where the connection is used

One of the features that comes in handy is to see where the connected account is used. From here, you can go directly to the flow.

Revoke the connection

There are thousands of platforms people use to get their job done. To prevent your Appmixer account from being messy and disorganised, make sure to disconnect the account you no longer use.

You've just learned how Data storage works. Now, let's finally see the real value of this feature. In this section, we will demonstrate a use case that some of us being on a forever-free Slack plan know very well.

Ever lost a message on Slack due to the fact that you're on a free plan? We did. Luckily for us and unluckily for Slack, there is a workaround. As tech geeks, we love workarounds, and we are somewhat proud to show you how to store Slack messages in the Appmixer Data storage so that there is never a message that is lost for good.

#sorrySlack

As you'll see, the flow we are about to build is more than simple. Below, see the overview of what it looks like once it's built-in Appmixer.

To get started hit the "Create Flow" button and drag & drop the Slack component to the canvas and choose either NewChannelMessage or NewPrivateChannelMessage – based on whether you want to store messages from public or private channels.

If you haven't authenticated your Slack account yet, now it's the right time to do so.

Next, you'll want to use the Storage module, or more specifically the "Set" component that saves new items to the Data storage. Below, see how we use a timestamp, message text and user to keep our database organised and clean.

We are all set! Except we aren't. There are for sure more channels from which we'd like to store messages in our Data storage. Let's adjust our flow a bit by adding more triggers / more Slack channels.

Next, we need to adjust the "Set" component a little bit. First, we need to choose the Data storage to which the messages will be saved. Second, we may want to use the channel name and timestamp as key...

... and the content of the message itself as value.

Let's do the same for other channels so that we store all messages, not only the ones coming into the "my-appmixer-tests" channel.

Now, every time a new message is sent to any of the Slack channels we've defined in the trigger components, the message gets saves to a Data storage.

You may wonder how the data looks once it's saved, don't you? Let's have a look.

After that, you're all set! ✅

Now that you know what purpose Data storage serves, let's create a new one for you! You'll see that the process of creating a new Data storage can hardly be easier.

We need to access the Storage tab in the Appmixer Studio to get started.

Next, click on the "Add Store" button.

You'll see a new Data storage was instantly created and is now ready to be used. You can either start saving data to your Data storage manually or by using the "Storage" module in a flow.

Now that you know what purpose Data storage serves and how to create one, let's go through the steps required to edit your Data storage.

There are a couple of things you can do with Data storage:

• rename Data storage,

• delete Data storage,

• create or store a new item in Data storage,

• delete items from Data storage,

• clear Data storage.

Some of the actions can be executed in the Storage tab, others in the flow builder. .

To give you a full context, let's see at all the components that can be used in the flow builder.

Besides that, you can do some manual edits in the Storage tab like renaming or deleting Data storage.

The Appmixer Studio is not only about flows and accounts. One of the features that make your life easier is Data storage. Data storage is, as the name suggests, a way to store data inside Appmixer using the Key-Value database (it's like a table with two columns, key and value).

Data storage lives in the Appmixer Studio under the "Storage" tab.

By default, you can use the already-created "Default store". In our example, we store Order IDs and Order Values in the store.

It's important to note that Data storage is represented by the "Storage" utility module in the flow builder. The components in this module allow you to use triggers like:

• OnItemAdded that triggers every time a new item is added to the data storage,

• OnItemRemoved that triggers every time an item is removed from the data storage,

• OnItemUpdated that triggers every time an item is updated in the data storage,

or actions like:

• Clear that clears the entire data storage,

• Find that helps you find values in data storage based on a Key text pattern,

• Get that helps you get a value from data storage, and use it further in your flow,

• Remove that removes a value in data storage,

• Set that sets a new value in a data storage.

In the next sections, we will show you how to create and edit data storage, and how to use it in a flow.

Insights. Something that can be of great help when controlling the performance of your flows, visualising data in a single place, and building your dashboard to make better decisions.

Let's see what Insights offer and how you can utilise this feature to get the most out of your data.

In the previous section, you learned about Logs. Now, it's the right time to show you the beauty of the Appmixer Dashboard.

The Dashboard can be found in the Insights tab and makes it easier to see custom-built charts in a single place.

Let's look at a simple example to understand its value. Say we started a simple flow that serves a single purpose: to save customer data to the Data storage. In this flow, we use Forms as one of the Utility modules and save some of the collected data to Data storage. In other words, every time someone fills out a form, some of the data is stored in our Key-Value Database.

As you may have noticed, we only store the job position of the customer. The reason being is we want to gather this data and visualise it in a simple chart to make better decisions in the future.

As you'll learn in the next section, there are multiple types of charts. This time, we decided to create a pie chart showing the job positions.

Simple, yet powerful.

Another example would be a bar chart showing the API requests of one of our flows. This time, we use a flow that checks the Bitcoin price and saves it to Data storage.

Again, something that takes a minute to set up in the Insight panel, but gives you the ability to easily see the number of API requests in one of your flows.

To sum it up, Dashboard not being the core of Appmixer, does a great job if you want to easily visualise the data aggregated and synced in your flows to make better decisions.

Next, we will go a little bit deeper and check the Charts and Chart types.

Now that you know the basics about Logs and Dashboard, let's finally look at how to create Charts in the Appmixer Dashboard.

It all starts by clicking the "Create Chart" button on the right. Once you do that, you'll open the panel where you'll set the Name, default Time range, and Chart type.

Note that charts consist of something we call Traces. These represent the data that is visualised in the particular chart and give you the flexibility to even use multiple sources of the data.

In the example below, we want to create something that ends up being a pretty useful pie chart showing the job positions of our customers.

Let's go step by step on how to create such a chart and demonstrate some of the features that await you in the Appmixer Dashboard.

First and foremost, we choose the Pie chart as shown below.

Next, we'll need to add the first Trace. In our example, a Trace represents each of the job positions. For the sake of simplicity, all Traces have the same source – a flow that is triggered by a form fill-out and saves data to Data storage. You could, nonetheless, use different sources for different Traces.

To finalise the setup of the first Trace, we may want to filter the data to only visualise one of the positions. Let's start with developers by using one of the Data aggregations – Filter.

Secondly, we shall add another Traces to visualise data even for the other job positions. To speed things up a little bit, let's look at the final setup knowing we deal with a few pre-defined positions: CTOs, CEOs, and Product Owners.

In the "Options" tab, all we do is renaming the Trace to make the chart easy to understand.

Aaaaaand it's done! ✅

Note that this is just one example of how charts can be created and used. There may be hundreds of use cases that we did not cover here, and that are waiting for you to discover. Before you do that, though, let's learn more about the Chart types and Data aggregations.

Logs, being one of the core features of the Insights panel, are a great help when identifying potential errors in your flow, or generally checking the flow performance and data that passed through it. As you already know from one of the previous sections, you can troubleshoot errors also in a flow. This time, nonetheless, we will focus on the "Logs" view in the Insights panel.

First and foremost, let's see where you can find Logs using the Insights panel.

By default, you'll see Logs for all your flows and for a given time range.

You can, nonetheless, filter the Logs only for specific flows. To do so, use the search bar on the left.

Besides the flow data messages histogram represented by the bar chart in the upper part, there are all Logs that allow you to see the performance of your flows in better detail, and identify potential errors. Note that after clicking on any of the Logs, a Log detail pops up giving you more details on the particular data message.

Now that you know how to navigate to Logs either in a flow or in the Insight panel, let's explore all the possibilities the Dashboard offers.

Reading all the previous articles about Insights, you've come to a place where there is just one last thing that remains to be explained: Data aggregations.

As import.io puts it, "Data aggregation is the process of gathering data and presenting it in a summarised format. The data may be gathered from multiple data sources with the intent of combining these data sources into a summary for data analysis."

Where do you find Data aggregations in Appmixer, you may wonder. Well, if you find yourself creating a chart, you'll find that out. 👇

Let's spend a minute looking at the aggregation types offered in Appmixer.

Playing around with the Dashboard features, you may have noticed there are multiple types of charts. We're doing all we can to empower you with a flexible way to visualise data in a way that suits your business needs. Therefore, we've included some of the widely used chart types which you can see below.

Let' spend a minute on each of them to explain what purpose they serve.

Finally, let's look at Data aggregations that help you visualise a high volume of data efficiently.

Once you start a free trial with Appmixer, you will be provided with unique credentials – Username, API URL and Password. Username and API URL can't be changed for technical reasons. Password, on the other hand, can.

We made changing a password as simple as it gets. Log into Appmixer Studio and click on the little Profile icon in the right upper corner.

Next, click "Change Password" and wait for the window to appear.

Now, you'll need to provide your old password as well as the new one. By clicking on the "Submit" button, your new password will be saved.

"Insights" help you access a high-level report on the monthly usage of your Appmixer instance: number of messages and message size. This view helps you see the performance of your Appmixer instance over time.

As you can see above, our Appmixer instance sends around 50 000 messages a month where one message has 230 bytes on average.

Let's clarify what a message means. The best explanation would be: "information in the JSON Object format that is sent from the out port to the in port in an Appmixer flow". The size of the message, of course, depends on the data size you're sending from one component to another.

Access Control List is a list of permissions associated with a system resource. In the case of Appmixer, these resources are components and routes.

• Components – this resource allows you to control access to certain components

• Routes – this resource helps you define ACLs to restrict access to Flows API

By default, all users have access to all components and routes.

Components

Using Appmixer ACL feature you can control access to certain components. All of that can be configured from Backoffice or through the API.

To demonstrate how this resource works, let's say we delete "user" in the components resource.

If an ordinary user opens Appmixer, he or she will see no components in the drag&drop designer.

Let's now add all components from "appmixer" vendor back with the following rule.

When the user refreshes Appmixer now, he or she will see all the Appmixer components back.

Let's break down those four properties you can set for each ACL rule.

Routes

You can define ACLs to restrict access to Flows API. The default setting is similar to the one for Components. All roles can access all actions on flows resource.

If you want to limit users from certain role, first you need to delete the general rule. We will show it on user role.

With this setting, any request to any /flows endpoint will result in 403 response code. The following example will show you how to limit access to /flows API for user scope to read only operations.

Have you ever wondered how to manage users that have access to your Appmixer instance? We'll gladly answer your question today.

All users that have access to your Appmixer instance, and thus, can create and manage flows, access all other parts of Appmixer like Insights, Data storage or Connected accounts are managed in the "Users" tab in the Backoffice.

You may note that you have your own user management system inside your own platform. Appmixer, in fact, automatically creates so-called shadow accounts for your end-users who may be otherwise managed in your own user management system. In other words, these two systems can seamlessly work together without one (negatively) influencing the other.

Having said that, our customers use the Appmixer user management system mainly to control who of their workmates has access to the Appmixer instance, and with which rights.

By clicking on the "pen" icon on the right side, a modal shows up giving you the ability to edit the user right.

As you can see, there are multiple scopes that determine the user rights:

• User can access the majority of what the Appmixer instance offers, except Backoffice.

• Admin can access all parts of Appmixer including the Backoffice.

Notice that besides the user scopes, you can assign "Vendors" to the user. Vendors allow you to control who can install new components into your Appmixer instance – components used in your flows that, as you know, can be fully customised to fit your business needs.

Vendors are represented by the first string of the custom component name. E.g. the default Send Email component available in Appmixer bears the name "appmixer.google.gmail.SendEmail". The Vendor, being the first string, is "appmixer" in this case.

Now imagine you wanted to build custom components representing some triggers and actions in your custom CRM to further use it in your flows. You'd create your vendor names for example "acme" and would have the option to assign this vendor to a user.

Once you do that, the user will have the ability to install custom components under this particular vendor. E.g. he or she would be able to install components using names like acme.customCRM.

Notice that if you're on our free trial, you're automatically assigned the "appmixer" vendor in the Backoffice. Thanks to that, you can start using the default components straight away as well as install your own without any complex configuration.

As you already know, Appmixer comes with a set of components. Some of those can be used directly, some require user authentication into a third-party system (Slack for instance). This authentication is usually done through the OAuth protocol which requires a pair of secrets stored in Appmixer. There are, nonetheless, more ways you can save those secrets in Appmixer. Using Appmixer Backoffice is the easiest one.

Let's say you want to start using Slack components. First, you need to register your Slack application on the Slack website where you will be provided with clientId and clientSecret. Once you have those, you can save them into Appmixer.

We can now add the clientId and clientSecret.

Then add clientId key with your client Id.

And then the clientSecret.

After that, you can use the Slack components in Appmixer.

You can add any key/value pair here. All the keys and their values will be available in your component's code at context.auth object and in the case of auth.js files directly in the context object.

You can use this configuration even for components that do not require user authentication into third-party applications. DeepAI component is a good example. In this case, you need an API key in order to use the Deep AI API, but you don't want your users to provide that API key. Instead of that, you may want to use your own API key for all your users to make their lives a little bit easier.

You rock! 🔥 You learned all the basics about Backoffice. Now, it's time to get some guidance on how Appmixer gets embedded into your platform, and preview what your end-users interact with.

As you already know, Appmixer comes with a set of Utilities and Applications. These represent components that can be used when building a flow. By default, we offer a wide range of Utilities and Applications, and we're constantly working on adding new ones.

The beautiful thing about Appmixer is that you can develop your custom components using Node.js, and upload them to the Appmixer engine using our CLI tool. Alternatively, you can adjust the current components to your liking using the same method.

Side note: Even though this is not one of the Backoffice features, it's rather about setting up your Appmixer instance, and therefore, related to Backoffice.

Below, see a high-level overview of how you can develop and upload your own components.

1. Define and implement your component

2. Pack and publish using our CLI

3. Use it in your workflows and integrations

As you – or your developers – can feel, the process does not take weeks or months as it's typical when building new APIs. Appmixer makes it super easy to implement new components fast and cost-effective.

"Flows" gives you the ability to access all flows created in your Appmixer instance – flows used by you or your team as well as those used by your end-users.

As you can see in the overview above, you can see a few flow attributes:

• Flow name

• Stage (stopped or running)

• User (user who created the flow identified by email)

• Created (time at which the flow was created)

• Modified (last time at which the flow was modified)

• # of Components (number of components used in the flow)

• Thumbnail (downloadable picture of the flow setup)

• Flow description (flow description written in JSON including the flow ID)

Notice that if you click through the flow name, a modal pops up showing you the Messages count and Messages size.

Furthermore, you can filter all flows either by flow name or stage (stopped or running) to narrow down your search results.

As already mentioned, "Flows" tab can be very helpful for your support team while troubleshooting errors in your end-users flows. The reason being is that the "Flow description" on the very right side offers an in-depth view of the flow setup (in a JSON format).

Now that you know a little bit about how Appmixer Backoffice works, let's have a look at ways to manage users in your Appmixer instance.

Knowing that you got to know the Appmixer Studio and Backoffice, it might be the right time to embed Appmixer into your product, right?

If that's the case, we are happy to introduce the first SDK Demo we've prepared for you: SDK Demo: Workflow automation.

As you already know, Appmixer excels mainly in two use cases one of which is exposing your end-users with a drag & drop visual designer that empowers them to build sophisticated flows from scratch. Alternatively, the drag & drop designer can serve as a great feature for building flows for internal processes – not necessarily something that would be exposed to your end-users users.

In both cases, you can use the SDK Demo to learn how to embed Appmixer into your product, and preview your configuration – in an imaginary SaaS platform – to see what Appmixer will look like once it lives inside your real platform.

Moreover, make sure to study the source code of the SDK demo to understand how to use the JavaScript SDK to display any of the Appmixer UIs in your product and to connect your users with the Appmixer virtual users to keep user data separate.

How to access your SDK Demo?

For those of you who recently started a free trial, refer to one of the onboarding emails. We've generated a special link that will help you download the SDK Demo: Workflow automation. Alternatively, you can download the SDK Demo below:

In the next section, you'll learn about the SDK Demo: Integration templates that give you a clear idea about how the simplistic version of Appmixer's integration builder looks like when embedded into your platform.

As you already know, the SDK Demo helps you get some hints on how to embed Appmixer into your product, and preview your configuration – in an imaginary SaaS platform – to see what Appmixer will look like once it lives inside your real platform.

The second SDK Demo we offer relates to the simplistic version of the integration builder. Say your end-users are not tech-savvy enough and want to integrate different apps as easily as possible. Impossible as it may seem, we've built a tool called Integration templates that does exactly that.

In one of the previous sections, we showed you how to create integration templates using our drag&drop visual designer. Now, it's the right time to preview your configuration and see what Appmixer will look like once it lives inside your platform.

Moreover, make sure to study the source code of the SDK demo to understand how to use the JavaScript SDK to display any of the Appmixer UIs in your product and to connect your users with the Appmixer virtual users to keep user data separate.

How to access your SDK Demo?

For those of you who recently started a free trial, refer to one of the onboarding emails. We've generated a special link that will help you download the SDK Demo: Integration templates. Alternatively, you can download the SDK Demo below: