Automate Your Intent Signals with Make and Rodz

TL;DR: Rodz detects intent signals, Make automates what happens next. This guide shows you how to connect a Rodz webhook to Make, route signals by type, and push them to Slack, HubSpot, Google Sheets, or email. No code required. You will walk away with three ready-to-use scenarios and tips for keeping your automation fast and reliable.

What Are Intent Signals and Why Automate Them?

An intent signal is a detectable event tied to a company: a new funding round, a leadership change, a job posting spike, a competitor mention, a public tender. These events carry timing-sensitive information. The sales rep who learns about a Series B the morning it closes has a far better shot at booking a meeting than someone who stumbles on the news a week later.

Rodz monitors thousands of sources, extracts these signals, and delivers them through an API and webhooks. That solves detection. But detection alone is not enough. Once a signal fires, someone needs to act on it: update a CRM record, notify a channel, log the event, draft an outreach email. If those steps are manual, speed evaporates.

Automation closes that gap. When a Rodz webhook fires, an automation platform like Make can instantly route the signal to the right tool, the right person, and the right workflow. The signal goes from “detected” to “acted on” in seconds, with zero manual intervention.

If you have not configured webhooks on Rodz yet, start with the webhook setup guide before continuing here.

What Is Make?

Make (formerly Integromat) is a visual automation platform that connects apps and services through “scenarios.” Each scenario is a pipeline: a trigger fires, data flows through modules (filters, routers, transformers, API calls), and actions execute at the end.

What makes Make a strong fit for signal automation:

• Visual builder. You drag modules onto a canvas and connect them. No scripting needed for most workflows.
• Webhooks as triggers. Make provides instant webhook URLs you can register with Rodz. Every incoming payload kicks off your scenario in real time.
• Router module. A single incoming webhook can branch into multiple paths based on conditions. One signal type goes to Slack, another to HubSpot, a third to Google Sheets.
• Error handling. Built-in retry logic, error routes, and break directives mean your automation does not silently fail.
• Hundreds of integrations. Slack, HubSpot, Google Workspace, Notion, Airtable, email, HTTP/REST. If a service has an API, Make can talk to it.

Prerequisites

Before you start building, make sure you have:

1. A Rodz API key with webhook permissions. See Getting Started with the Rodz API if you need to set this up.
2. At least one active signal configured in Rodz. The webhook will not fire unless signals are running.
3. A Make account. The free tier supports two active scenarios and 1,000 operations per month. That is enough to follow this guide and test your workflows.
4. Access to the destination tools you want to automate: Slack workspace, HubSpot account, Google Sheets, or an email address.
5. Basic comfort reading JSON. Rodz webhook payloads are JSON objects. You will map their fields to Make module inputs.

For details on Rodz API endpoints, rate limits, and error codes, consult the API reference.

Step 1: Create a Webhook Trigger in Make

Every Make scenario starts with a trigger. For real-time signals, you want a Custom Webhook trigger.

1. Log into Make and click Create a new scenario.
2. Click the large ”+” icon on the canvas, search for Webhooks, and select Custom webhook.
3. Click Add to create a new webhook. Give it a descriptive name, such as “Rodz Intent Signals.”
4. Make generates a unique URL. Copy it. You will need it in the next step.

Do not close the scenario editor. Make is now listening on that URL and waiting for a sample payload so it can learn the data structure.

Step 2: Register the Webhook URL in Rodz

Now tell Rodz to send signal events to the Make webhook URL. You can do this with a single API call.

curl -X POST https://api.rodz.io/v1/webhooks \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://hook.make.com/your-unique-id",
    "events": ["signal.created"],
    "description": "Make automation webhook"
  }'

Replace YOUR_API_KEY with your actual key and paste the Make webhook URL. The events array controls which events Rodz sends. signal.created covers all new signals. You can narrow this later.

Once you run this command, Rodz returns a webhook object with an id and a secret. Save the secret. You will use it to verify payloads if you add an HMAC check later (covered in the optimization section).

For a deeper walkthrough of webhook creation, payload structure, and retry behavior, see the full webhooks guide.

Step 3: Send a Test Payload

Make needs a sample payload to map fields. You can either wait for a real signal to fire or trigger a test event from the Rodz dashboard.

To trigger a test manually via the API:

curl -X POST https://api.rodz.io/v1/webhooks/YOUR_WEBHOOK_ID/test \
  -H "Authorization: Bearer YOUR_API_KEY"

Switch back to Make. The custom webhook module should now show the received data structure. You will see fields like signal_type, company.name, company.domain, signal.details, signal.detected_at, and more.

Click OK to confirm the structure. Make now knows how to parse every Rodz signal event.

Step 4: Route Signals by Type with the Router Module

This is where automation gets powerful. A single webhook delivers all signal types: funding rounds, job postings, leadership changes, competitor mentions. You probably want different actions for each.

1. Click the ”+” after the webhook module and search for Router. Add it.
2. The router creates branches. Each branch gets a filter that checks a condition.
3. Click the wrench icon on the first branch and set a filter: signal_type equals funding_round.
4. Add a second branch with a filter: signal_type equals job_posting.
5. Add a third branch with a filter: signal_type equals leadership_change.
6. Add as many branches as you need. You can also create a fallback branch with no filter that catches any signal type not matched above.

Each branch now acts as an independent pipeline. A funding round signal flows down branch one and ignores the others. A job posting flows down branch two. This keeps your actions clean and targeted.

Useful filter examples

Filter condition	Use case
signal_type equals funding_round	Notify sales about new funding
signal_type equals leadership_change AND signal.details.role contains CTO	Alert your technical sales team
signal_type equals job_posting AND signal.details.count greater than 5	Spot companies on a hiring spree
company.industry contains SaaS	Filter for your target vertical

Step 5: Add Action Modules

Now connect each router branch to a destination. Here are the four most common actions.

Action A: Post to Slack

1. On the funding round branch, click ”+” and search for Slack > Create a Message.
2. Connect your Slack workspace if you have not already.
3. Select the channel (e.g., #sales-signals).
4. Build the message using mapped fields:

New funding signal detected
Company: {{company.name}}
Amount: {{signal.details.amount}} {{signal.details.currency}}
Round: {{signal.details.round_type}}
Detected: {{signal.detected_at}}

5. Click OK. Every time a funding_round signal arrives, Slack gets a clean, structured notification within seconds.

Action B: Create or Update a HubSpot Contact/Deal

1. On a branch (e.g., leadership changes), click ”+” and search for HubSpot > Create/Update a Contact or Create a Deal.
2. Map company.name to the company name property, signal.details fields to custom properties you have set up in HubSpot, and signal.detected_at to a date field.
3. Use the Search module first to check if the company or contact already exists. Connect it with a router to either update or create.

For a more detailed HubSpot integration, see the dedicated guide: Connect Rodz to HubSpot.

Action C: Log to Google Sheets

1. On a catch-all or specific branch, add Google Sheets > Add a Row.
2. Connect your Google account and select the target spreadsheet and sheet.
3. Map columns: Company Name, Signal Type, Details, Date Detected, Source URL.
4. This creates a living log of every signal, perfect for weekly reviews or reporting dashboards.

Action D: Send an Email Alert

1. Add Email > Send an Email (or use Gmail, Outlook, or any mail module).
2. Set the recipient to your sales manager or a distribution list.
3. Build a subject line: [Rodz Signal] {{signal_type}} — {{company.name}}
4. Body:

Hi team,

A new intent signal has been detected:

Company: {{company.name}}
Signal: {{signal_type}}
Details: {{signal.details.summary}}
Detected at: {{signal.detected_at}}

Review this signal in the Rodz dashboard or take action directly.

5. Use this sparingly. Email works best for high-priority, low-volume signals. For high-volume signals, Slack or Sheets are better fits.

Three Ready-to-Use Scenarios

Here are three complete scenario blueprints you can build in under 15 minutes each.

Scenario 1: Funding Alerts to Slack + Google Sheets

Trigger: Rodz webhook (Custom Webhook) Router branch 1: Filter signal_type = funding_round > Slack message to #funding-alerts > Google Sheets row append Router branch 2: All other signals > Google Sheets row append (different sheet tab)

Why it works: Your sales team sees funding rounds instantly in Slack while every signal gets logged for analysis. Two branches, four modules, five minutes to build.

Scenario 2: Leadership Changes to HubSpot + Email

Trigger: Rodz webhook Filter: signal_type = leadership_change Step 1: HubSpot Search (find company by domain) Step 2a (found): HubSpot Update Company (add note with signal details) Step 2b (not found): HubSpot Create Company + Create Contact with the new leader’s details Step 3: Email notification to the assigned account owner

Why it works: Your CRM stays current without anyone manually entering data. When a new VP of Sales starts at a target account, HubSpot reflects it and the rep gets an email. That is a warm intro waiting to happen.

Scenario 3: Job Posting Surge to Slack + Spreadsheet Scorecard

Trigger: Rodz webhook Filter: signal_type = job_posting AND signal.details.count > 3 Step 1: Google Sheets, append row with company name, number of openings, roles, detected date Step 2: Slack message to #growth-targets with a summary

Why it works: A company posting four or more roles at once is growing aggressively. That is a buying signal. By filtering on count, you ignore one-off postings and focus on the companies that are scaling, the ones most likely to need your product.

Optimization Tips

Once your scenarios are running, apply these practices to keep them fast, reliable, and cost-efficient.

Validate Payloads with HMAC

Rodz signs every webhook payload with an HMAC-SHA256 signature using the secret from step 2. In Make, you can add a Webhook Response module or use a custom function to verify the X-Rodz-Signature header matches the computed hash of the body. This prevents spoofed requests from triggering your workflows.

Use Filters Aggressively

Every module in Make costs one operation. If you run a scenario on every signal but only care about funding rounds, you burn operations on signals you discard. Place filters as early as possible, right after the webhook trigger, to short-circuit irrelevant events before they hit downstream modules.

Set Up Error Handling Routes

Right-click any module in Make and select Add error handler. Use the Resume directive for transient failures (API timeouts) and Break for persistent ones (invalid credentials). The Break directive pauses the scenario and notifies you, so you can fix the issue before data piles up.

Batch Logging with Array Aggregator

If you receive many signals in bursts, adding a row to Google Sheets for each one generates a lot of API calls. Instead, use Make’s Array Aggregator module to collect signals over a short window, then write them all in a single Google Sheets > Add Multiple Rows call. This reduces operations and avoids hitting Google’s rate limits.

Monitor Execution History

Make logs every scenario execution with timestamps, input/output data, and error details. Check this log weekly. Look for patterns: consistent filter misses may mean your signal configuration in Rodz needs adjusting. Repeated errors on a specific module usually point to expired credentials or changed API schemas.

Keep Scenarios Modular

Resist the temptation to build one massive scenario that handles everything. Instead, create separate scenarios for separate concerns: one for Slack notifications, one for CRM updates, one for reporting. Register multiple webhooks in Rodz (one per scenario) or use a single webhook with Make’s router. Modular scenarios are easier to debug, update, and turn on and off independently.

Frequently Asked Questions

How many signals can Make handle per minute?

Make processes webhook events sequentially within a single scenario execution, but it can handle multiple concurrent executions. On the free plan, scenarios run sequentially. On paid plans, you can enable parallel execution. For most teams, Rodz signal volume (tens to low hundreds per day) is well within Make’s capacity. If you expect thousands of signals per hour, consider batching or upgrading to Make’s Teams or Enterprise plan.

Does Make store my signal data?

Make retains execution logs (including input and output data) for a period that depends on your plan: 15 days on Free, 30 days on Core, and longer on higher tiers. The data passing through modules is ephemeral during execution. For permanent storage, always log signals to a destination like Google Sheets, a database, or your CRM.

Can I replay a failed webhook event?

Yes. Rodz retries failed deliveries automatically (see the webhooks guide for retry policy details). On the Make side, if a scenario execution fails, you can go to the execution history, click into the failed run, and re-run it manually. This is useful when a downstream service was temporarily unavailable.

What happens if my Make scenario is turned off?

Rodz will still send webhook payloads to the URL. Make will receive them but will not process them. Depending on the Make plan, queued events may be processed when the scenario is turned back on, or they may be lost. To avoid gaps, use Rodz’s webhook retry mechanism combined with Make’s Incomplete Executions feature, which stores unprocessed bundles for later execution.

How do I handle different signal payloads with different field structures?

Rodz signals share a common envelope (signal_type, company, signal.detected_at) but the signal.details object varies by type. In Make, after the router splits by signal_type, each branch “knows” what fields to expect. Map fields specifically for that branch. If a field might be absent, use Make’s ifempty function to provide a fallback value.

Can I use Make to call the Rodz API, not just receive webhooks?

Absolutely. Add an HTTP > Make a Request module to call any Rodz endpoint. For example, you could build a scenario triggered by a schedule that calls GET /v1/signals to fetch recent signals, processes them, and pushes results to a dashboard. This polling approach complements webhooks for use cases where you want periodic batch reports rather than real-time alerts. Check the API reference for available endpoints and rate limits.

Is there a cost to using Rodz webhooks?

Registering and receiving webhooks is included in your Rodz API plan at no extra cost. The costs on the Make side depend on your plan and the number of operations your scenarios consume. Each module execution counts as one operation. A simple three-module scenario (webhook + filter + Slack message) uses three operations per signal. Plan your scenarios accordingly and monitor usage in Make’s dashboard.

How do I secure the webhook URL?

Three layers of security work together. First, use HTTPS only (Make webhook URLs are HTTPS by default). Second, verify the HMAC-SHA256 signature Rodz includes in the X-Rodz-Signature header. Third, in Make, you can add an IP restriction filter as the first module to accept requests only from Rodz’s published IP ranges. These three measures ensure that only legitimate, untampered payloads trigger your workflows.

Next Steps

You now have a working pipeline: Rodz detects intent signals, Make routes them, and your tools act on them automatically. From here, you can:

• Expand your signal coverage. Add more signal types in Rodz and create new router branches in Make.
• Layer in enrichment. Use Make’s HTTP module to call enrichment APIs before pushing data to your CRM.
• Build dashboards. Connect Google Sheets output to Looker Studio or Notion databases for visual reporting.
• Explore the API further. The full Rodz API documentation covers every endpoint, including batch queries, signal filtering, and account management.

The goal is to remove every manual step between a signal firing and your team acting on it. With Rodz and Make connected, you are most of the way there.