Glossary

ACID stands for atomicity, consistency, isolation, and durability. These four properties guarantee database accuracy and stability during transactions. See this article for more information.

Make marks this functionality with a badge. Note that the ACID badge indicates the use of these properties and does not indicate whether the module is an instant or polling trigger.

You can create, read, update, or delete data with an action module. Action modules are the most common type of module and can be at the beginning, middle, or end of a scenario. There is no limit to the number of action modules in your scenario.

There are two ways you can use scenarios in Make depending on how you want your scenario to function:

You can change between active and inactive whenever you like on the Scenarios tab.

An aggregator is a type of module that allows you to merge multiple bundles into one single bundle. Aggregators are useful in making data readable for certain modules or generating meaningful output. Make offers:

See Also Aggregator article.

Within a bundle, data items of the same type are sometimes in an array. You can find an array by looking at the details of a bundle.

Depending on the details of your scenario, you can map other modules to a specific item in an array or use iterators and aggregators to manipulate your data into other formats.

When mapping, Make marks arrays with [ ].

When designing a scenario, use an array aggregator to merge multiple bundles into one single bundle. This may be necessary to format data properly for subsequent modules. The array aggregator also lets you define your target data structure.

See Also Aggregator article.

The Auto commit option defines how Make process data transactions. Enabling Auto commit switches all operations to the commit phase. In the case of an error, data commits immediately and you cannot restore any lost data.

See Also Scenario execution, cycles, and phases article.

Make lets you import and export scenarios via a blueprint, a file in JSON format. Your blueprint contains all of your modules and settings except for connections. When importing from a blueprint, you must add your connections.

Using a break directive lets you resolve errors manually and helps when you want more human oversight of errors. When an error occurs, the break directive stops execution of subsequent modules and stores the error in the queue of incomplete executions. Then, the break directive creates a separate record for each bundle that causes the error (available under the Incomplete executions tab > Details). Here, you can manually resolve the error and process all unprocessed bundles. The scenario execution history shows the status as Warning.

A bundle is a chunk of data and the basic unit for use with modules. A bundle consists of items, similar to how a bag may contain separate, individual items.

When you need a quick duplicate of a module (for example when using data store modules on each branch of a router), use the clone module command to make an exact duplicate of your module. It appears instantly and has the same settings and variables as the original module. You can then drag it to wherever you need it and customize the settings. Changes in the original do not affect the clone and vice versa.

You can duplicate a scenario from the Scenario tab by using the Clone option on the drop down menu for the scenario. Possible uses include sales with multiple pipelines. Use Clone scenario to create a duplicate scenario and customize for each pipeline. Changes in the original do not affect the clone and vice versa.

Use the commit error handling directive when you want to stop the execution of the scenario completely but still have the sent data. When there is an error, the commit directive:

The scenario execution history displays the status as Success.

Commit is the third phase of a scenario execution. If the operation phase is successful for all modules, the commit phase begins and makes all data changes permanent. This means that Make sends information to all the services involved in the operation phase about its success.

See Also Scenario execution, cycles, and phases article.

A connection allows Make to communicate with an app/service. When adding an app/service to a Make, you may have to create a connection between Make and that app/service to retrieve or send necessary data. Make asks for only the specific permissions required. As a result, some apps/services may ask for permission multiple times. For more information, see Connecting to services

A converger is the counterpart to the router module and merges several routes into one route. There is no converger module available in Make, but there is a workaround, allowing you to reduce the duplication of modules in different routes.

See Also Converger workaround.

When working with multiple scenarios, use the copy module command to create a duplicate of your module that you can paste to any scenario. It functions similar to cutting and pasting text on your computer. Although cloning a module is faster, copying allows you to paste the module in another scenario. Copying a module will also copy any filters before the original module. You can also box select (shift + drag) several modules and copy them with the ctrl + C shortcut. This is helpful when creating complex scenarios.

A cycle is the operation and commit/rollback phases of scenario execution. A scenario may have one or more cycles (one is the default).

See Also Cycles.

The data loss option enables data to be lost if Make fails to save a bundle to the queue of incomplete executions (e.g. due to a lack of free space). Enable data loss to prevent interruptions in the overall scenario execution, e.g. a scenario where it is imperative the scenario keeps running and the incoming erroneous data is not that important.

See Also Scenario settings article.

A data store is a built-in database in Make .You can use data stores to store data from scenarios or transfer data between individual scenarios or scenario runs. Your account includes data stores, so you do not have to register at a third-party service.

When you create a data store, you need to create a data structure that formats your data store in Make. Think of the data store as a spreadsheet and the data structure as the headers. The data structure defines the kind of data (i.e. text, numeric, etc.) that the data store records. You can view and manage your data structures from the data structures page. You can reuse your data structures.

Data transfer is the amount of data transferred through your scenario.

See Also Pricing parameters.

The diagram is a visual representation of your scenario and appears exactly the same way as you see your scenario in the Scenario editor. Use the diagram tab to quickly view:

A directive allows you to control how Make handles errors. There are six error handling directives:

The Explain flow button allows you to see how the data will flow through from module to module before you run your scenario. Clicking the Explain flow button starts an animated visualization of how your bundles flow through your scenario.

A filter helps you select bundles that fit specific criteria. You can add a filter between two modules to be sure that bundles received from the preceding modules fulfill specific conditions. Make offers:

See Also Filtering article.

Finalization is the fourth and final phase of scenario execution. The finalization phase closes open connections (e.g. FTP connections, database connections, etc.) and marks the scenario as completed.

Functions allow you to create complex formulas when mapping items. The functions available in Make are similar to functions in Google Sheets and those in other programming languages. The functions let you perform various transformations of item values, such as converting a text to uppercase, trimming a text, converting a date into a different format, and many others. Hovering over a function gives you a brief explanation and usage example.

See Also Functions article.

Make maintains a history of your scenario and records:

You can view this information by clicking on history in Scenario detail or in the Diagram. Viewing from the diagram allows you to see currently running executions and stop them if necessary.

Use the ignore error handling directive when you want a scenario to continue processing the next bundles if an error occurs. The ignore directive does not process the bundle where the error occurred through subsequent modules. The scenario execution status is marked as Success.

The ignore directive is the default when you use a module instead of an error handling directive.

Sometimes Make cannot successfully finalize a scenario execution due to an error.

Make stores incomplete executions in a folder named Incomplete Executions. Each stored incomplete execution can be resolved either manually or automatically.

Initialization is the first phase of scenario execution. During the initialization phase, Make creates all necessary connections (for example, to databases, email services, etc.). The initialization phase also checks if each module is capable of performing its intended operation(s).

An item is data that is part of a bundle. There are several different types of items: text, number, boolean (yes/no), date, time, buffer (binary data), collections, and arrays. You can find these details by clicking on the inspector at the upper-right of your module.

When creating a scenario, use an iterator to divide one bundle into smaller separate bundles. Subsequent modules then process the bundles separately. One common use is when automatically uploading email attachments to a cloud drive.

You can find iterators under Flow control of the tools section.

See Also Iterator article.

The keychain helps you to administer the keys you have stored in Make. Each key is a unique identifier used for encryption.

See Also Keys.

When creating a new data store, you can assign unique identifiers to each record. Make will create a key for you if you leave the key field blank. You can also map the value of your key to make it easier to find information in your data store.

Mapping links the modules in your scenario. When you map an item, you connected the data retrieved by one module to another module to perform the desired action. For example, you can map the email address and subject lines from the Email > Watch emails module to Google Sheets > Add a row and create a spreadsheet of email addresses and subjects.

See Also Mapping.

Modules are the main building blocks of automation in Make. Modules represent actions that Make performs with an app. Each app typically contains several modules that read, create, update, and delete data.

Clicking the notes button lets you add notes to your modules in your scenario. The notes feature is very useful for keeping track of webhook links. You can also use notes to explain scenario routes, which is useful for teams working on complex scenarios.

A numerical aggregator lets you to apply functions like SUM or AVG to numerical values. Numerical aggregator then return the results in one bundle.

Every time a module in a scenario performs an action, it counts as an operation. For example, when your scenario reads a record from Pipedrive, writes a row into a Google sheet, or posts a tweet, each counts as one operation.

More examples that count as operations:

Depending on the complexity of the process you’re automating, your scenario can perform anywhere from two operations to thousands of operations in a single run.

See Also Counting the number of operations.

Operation is the second phase of scenario execution. During the operation phase read and/or write operations are performed:

When you need a module to perform a task multiple times, for example make an API call, use a repeater. Placing a repeater module before another module makes the subsequent module repeat its task. You can confirm by inspecting the bundles output by the subsequent module.

See Also Repeater section in Flow control article.

Use the Resume directive when you want scenario execution to continue even though an error occurs. The Resume directive allows subsequent modules continuing processing as if no error took place. The Scenario execution history displays the status as Success.

Make does not feature a retry error handling directive, though there are two workarounds that mimic its functionality.

See Also Retry workaround articleRetry.

Use the Rollback directive when you want to mark the error and return modules to how they were before the scenario ran. The Rollback Directive stops the scenario execution immediately. Then a rollback phase starts on all modules to revert each module back to its initial state. The Rollback directive marks the scenario execution status as Error.

See Also Directives for error handling article.

Rollback is a phase that occurs when there is an error during the operation or commit phase on any module. The scenario execution stops the operation or commit phase and starts the rollback phase, reversing all changes in data.

See Also ACID modules.

A router allows you to add new routes to a scenario so you can branch your flow into several routes and process the data within each route differently.

See Also Router article.

Once a scenario is configured, you can execute it by clicking the play icon.

This way, you can verify that the scenario runs as you expect.

If everything is working properly, you can activate the scenario. Once activated, thescenario execute according to its schedule.

If everything does not run as expected, you can visit our error handling article to learn how to handle errors.Introduction to Error Handling

A scenario is a series of modules that users create to automate apps/services. Creating a scenario allows you to transfer and transform selected data between apps/services via modules.

Whenever your scenario runs, it constitutes one scenario execution. Make marks the scenario execution as either success, warning, or error. You can find this information on the right hand side of the Diagram or on the History tab.

In technical terms, scenario execution refers to a sequence of phases. Execution starts with the initialization phase, continues with at least one cycle composed of the operation and commit/rollback phases and ends with the finalization phase.

It is possible to receive emails when errors occur by enabling email notifications from the email notification options tab of the dashboard.

Make allows you to define when and how often an active scenario runs. Use the Schedule setting panel under the Options tab and choose Scheduling to set your preferred schedule.

Using the Sequential processing options allows you to monitor and resolve errors in greater detail. If you enable sequential processing, Make stops processing the task sequence until you resolve all incomplete executions. With sequential processing enabled, you can address all incomplete executions in the order in which they occurred.

If you disable Sequential processing, the scenario continues to run according to its schedule with repeated attempts to rerun the incomplete executions.

See Also Scenario settings article, Incomplete executions article.

You can use a table aggregator to create a table from multiple bundles. The table aggregator merges values based on your specified column and row parameters and outputs into a single bundle. One possible use is compiling blog posts or emails into a single email summary.

Use teams to control and separate access to scenarios and other Make data. You can assign users to multiple teams and specific roles on each team. Members of a team have access only to scenarios and data that belong to their team and role.

See Also Teams article.

A template is a pre-developed scenario that you can customize to your specific needs. Make has made many templates for you to quickly create useful scenarios.

Make also allows you to submit your own templates for sharing with the Make community.

When a module requires text in a single bundle, use a text aggregator to merge values into a single bundle. You can map text aggregators the same way as modules or other tools to create the bundle you need.

The text parser tool allows you to add these modules:

Make uses transactional processing to describe the scenario execution cycle. A transaction consists of four phases during which Make creates or updates data in a way that ensures data integrity across apps and services. There are 4 phases:

See Also Scenarion execution, cycles, and phases.

Every scenario has a trigger, an event that starts your scenario. A scenario must have a trigger. There can only be one trigger for each scenario. When you create a new scenario, the first module you choose is your trigger for that scenario. Create a trigger by clicking on the empty module of a newly created scenario or moving the clock/lightning icon to another module.

There are two types of triggers:

When integrating with third-party apps/services, webhooks are a way for those apps to let Make know when something happens. A webhook is a notification containing data about an event, sent by one app to another app or site.

Make uses webhooks as instant triggers to immediately execute the scenario. Webhooks create a URL that you can call from an external app or service, or from another Make scenario.