Replay Webinar : Build your first automations with pipedrive and make replay

🚀 Introduction to Make and Pipedrive Automation

This webinar focuses on how to build practical automations using Make and Pipedrive. The speaker presents Make as a visual automation platform that allows users to connect different tools together without needing advanced technical skills or custom development.

The main idea of the session is to show how businesses can save time by automating repetitive actions. Instead of manually copying information from one tool to another, Make can automatically move data between platforms such as Pipedrive, Slack, Google Sheets, Gmail, forms, scheduling tools, and many other applications.

The speaker explains that Make is especially useful because it can connect with many tools through pre-built modules, APIs, HTTP requests, and webhooks. This means that even if a tool does not have a direct integration available, it may still be possible to connect it using its API.

🧩 The Basic Structure of an Automation

A Make automation, also called a scenario, usually follows a simple structure. It starts with an event, checks conditions if needed, and then performs one or several actions.

Element	Meaning	Example
Trigger	The event that starts the automation	A deal is won in Pipedrive
Filter	A condition that decides whether the scenario should continue	Only continue if the deal is in the sales pipeline
Action	The task performed by Make	Send a Slack message

The speaker explains that this logic can be applied to many business situations. For example, an automation can start when a new email arrives, when a form is submitted, when a meeting is booked, or when a CRM record is updated.

⚡ Instant Triggers and Scheduled Triggers

The webinar explains the difference between instant triggers and scheduled triggers. This is an important distinction when building automations because it affects how quickly the workflow runs.

An instant trigger starts the scenario immediately when something happens. This is usually powered by a webhook. For example, when a deal is marked as won inside Pipedrive, the information can be sent instantly to Make, and the automation can begin right away.

A scheduled trigger works differently. Instead of receiving information immediately, Make checks an application at regular intervals. Depending on the Make plan and the scenario settings, this can happen every few minutes, every hour, once per day, or only when the user manually runs the scenario.

The speaker shows that both approaches are useful. Instant triggers are better for real-time processes, while scheduled triggers are useful when an application cannot send information automatically.

🌐 Understanding Webhooks

Webhooks are one of the most important concepts covered during the webinar. The speaker explains them in a simple way: a webhook is a special URL that can receive data from another platform.

In the demonstrated workflow, Make creates a webhook URL. This URL is then added inside Pipedrive. When a specific event happens in Pipedrive, such as a deal being marked as won, Pipedrive sends data to that webhook URL. Make receives the information and starts the scenario.

This makes webhooks very useful for real-time automation. Instead of Make constantly checking whether something changed, the external tool sends the data directly when the event happens.

🔎 Why webhook naming matters

The speaker strongly recommends naming webhooks clearly. In Pipedrive, once a webhook name is created, it cannot easily be changed. Poor naming can therefore create confusion later, especially when several automations are active.

A good webhook name should make it clear which scenario it belongs to, which tool it connects with, and what its purpose is. This makes troubleshooting and maintenance much easier.

🛠️ Exploring the Make Interface

The webinar gives an overview of the Make interface and the main sections users need to understand. The Scenarios area contains all automations. Each scenario is made of modules connected together visually.

The Connections section stores the authenticated links between Make and external applications. For example, if Make needs to access Pipedrive, Slack, or Google Sheets, each of these tools requires a connection. The speaker shows that using the wrong connection can cause errors, even if the scenario itself is correctly built.

The webinar also briefly introduces templates, which are pre-built automation examples. These can be useful for beginners who want inspiration or want to understand what Make can do with tools like Pipedrive, Gmail, Google Sheets, or Slack.

🗄️ The Role of Data Stores

The speaker introduces the concept of the Data Store in Make. A Data Store is a place where information can be saved directly inside Make.

This can be useful when a scenario needs to store temporary data, check values quickly, or keep a small internal record without sending information to another platform. Although the webinar does not go deeply into this feature, the speaker mentions that Data Stores can be very useful in more advanced automations.

💬 Main Example: Sending a Slack Message When a Deal Is Won

The main demonstration of the webinar shows a simple but powerful use case: sending a Slack notification when a deal is won in Pipedrive.

The automation starts in Pipedrive. When a deal status changes to “won”, Pipedrive checks whether the deal matches the right conditions. For example, the speaker filters deals so that only deals from a specific sales pipeline continue through the automation.

If the conditions are met, Pipedrive sends information to Make through a webhook. The data includes elements such as the deal ID, deal value, and deal owner name.

Make then receives the data, retrieves the deal information, and sends a message into a Slack channel. The message congratulates the salesperson and includes the value of the deal.

💡 Example of the automated Slack message

The Slack message can include dynamic information, such as the name of the sales representative, the amount of the deal, and the date when the deal was won. This makes the notification feel personalized and useful for the whole team.

This use case is simple, but it clearly shows the value of automation. The sales team does not need to manually announce wins, and everyone can be informed automatically in real time.

📅 Formatting Dates and Preparing Data

The speaker also shows how Make can transform data before sending it to another tool. One example is date formatting. Data coming from Pipedrive may include a full timestamp with the date and time, but the user may only want to display the date in a cleaner format.

Make includes functions that allow users to format dates, adjust text, create variables, and prepare values before sending them to the next step of the scenario.

This is important because tools often store data in different formats. Make acts as a bridge between these tools and can clean or adapt the information before passing it forward.

🔀 Using Routers to Split a Scenario

The webinar then introduces routers. A router allows one scenario to split into several paths. This means that one trigger can lead to multiple actions.

For example, when a deal is won in Pipedrive, the same automation could send a Slack message, add the deal to Google Sheets, create a task in Asana, and send an email notification.

The speaker explains that Make processes routes in order. This is why it is useful to keep scenarios visually organized and to understand the logic of the path the data follows.

🎯 Filters and Conditional Logic

Filters are used to control whether data should continue through a route. This prevents unnecessary actions and makes the automation more precise.

For example, a filter can check whether a deal ID exists before adding information to Google Sheets. Another filter can check whether a deal belongs to a specific pipeline or whether a contact person is attached to the deal.

• Check if a value exists before continuing.
• Only process deals from a specific pipeline.
• Send data to different tools depending on conditions.

The speaker also introduces IF/ELSE logic, which allows a scenario to behave differently depending on the data received. For example, if a contact already exists, the scenario can continue normally. If the contact does not exist, Make can search for it or create a new one.

📊 Adding Deal Information to Google Sheets

Another practical example shows how Make can send Pipedrive data into Google Sheets. This can be useful for sales reporting, backup, analysis, or internal tracking.

The speaker creates a Google Sheet with columns such as deal ID, value, date, and owner. Then, Make maps the information received from Pipedrive into the correct columns.

Google Sheets Column	Data Sent by Make
Deal ID	The unique identifier of the deal
Deal Value	The amount associated with the deal
Date	The date when the automation runs or when the deal is won
Owner	The salesperson responsible for the deal

This example shows how Make can remove manual data entry. Once the automation is active, every matching deal can be recorded automatically.

🧠 Variables and Data Normalization

The webinar also introduces variables. Variables are useful when data needs to be reused, cleaned, or transformed before being passed to another module.

For example, the speaker shows how a name can be transformed into uppercase or formatted in a cleaner way. This kind of transformation is useful when different tools use different naming styles or when data needs to be standardized before being stored.

Variables are especially useful in larger scenarios because they help organize the information and make the workflow easier to understand.

📦 Understanding Bundles

The speaker briefly explains how Make handles bundles. A bundle is one set of data processed by a module.

For example, if a module retrieves one deal, Make processes one bundle. But if a module lists 18 deals, Make creates 18 bundles and sends each one through the next steps of the scenario.

This is important because it can affect how many times an action runs. If a user is not careful, a scenario may send several messages, create several rows, or repeat the same action multiple times.

More advanced Make modules, such as iterators and aggregators, can help control how bundles are processed, but the speaker mentions that this would require a dedicated session.

⚠️ Error Handling and Troubleshooting

The webinar includes a real troubleshooting moment when a Pipedrive module cannot find a deal. The speaker explains that the issue comes from using the wrong Pipedrive connection.

This example is useful because it shows a common mistake. When users manage several accounts or workspaces, they need to make sure each module uses the correct authentication.

The speaker also mentions error handlers, which can be used to decide what should happen when a module fails. For example, an automation could continue, retry, ignore the error, or send a notification.

✅ Best practices highlighted during the webinar

• Use clear names for scenarios, webhooks, and connections.
• Check that each module uses the correct account connection.
• Store incomplete executions to avoid losing failed runs.
• Avoid changing webhook field names after mapping them in Make.

The speaker strongly recommends enabling the option to store incomplete executions. This allows users to inspect failed runs and retry them later instead of losing the data.

🔮 Advanced Features Mentioned

Although the webinar is mainly introductory, several advanced Make features are mentioned. These include iterators, array aggregators, HTTP requests, routers, variables, and error handlers.

These features allow users to build much more complex workflows. For example, Make can process many records at once, combine data from several tools, clean information, send it to multiple platforms, and handle errors intelligently.

The speaker makes it clear that Make can be used for much more than simple notifications. It can become a central automation layer between sales, marketing, operations, customer success, and reporting tools.

🏁 Conclusion

The webinar concludes by reminding viewers that Make is a powerful tool for connecting Pipedrive with other business applications. Even a simple automation can save time, reduce manual work, and improve team communication.

The speaker encourages viewers to experiment with simple scenarios first, then gradually explore more advanced features such as routers, filters, variables, and error handling.

Future webinars are mentioned, with the possibility of going deeper into Make, Pipedrive, and other integrations.