If your B2B go-to-market team is drowning in manual tasks and copy-pasting between Salesforce, HubSpot, and Slack, you’re not alone. Everyone says automation will fix it, but getting all these tools to talk to each other—without making a bigger mess—can feel like wrangling cats. This guide is for GTM operators, sales/marketing ops folks, and anyone who’s sick of “integrations” that break, get ignored, or just add more busywork.
I’m going to walk you through how to actually connect these three platforms using Make, what to watch out for, and how to make sure you’re automating what matters (and not just adding more duct tape).
Why Automate These Integrations? (And When You Probably Shouldn’t)
Let’s be blunt: Not every process needs to be automated. If you’re still figuring out your workflows, hold off. Automating chaos just creates automated chaos.
But if you’ve got repeatable, well-understood sales and marketing processes, tying Salesforce, HubSpot, and Slack together can:
- Cut down on mindless manual updates
- Shorten response times for leads
- Reduce “oh, I thought you updated that” mistakes
- Free humans up for real work
If your team is still debating what counts as a lead or changing pipeline stages weekly, sort that out first. Automation won’t fix a moving target.
Step 1: Get Clear on What You Actually Want to Automate
Don’t start by wiring up every tool just because you can. Start with these questions:
- What’s the repetitive task that eats up the most time?
- Where do handoffs between teams fall apart?
- Where are you losing deals or missing leads because of slow follow-up?
Common real-world automations in a B2B GTM stack:
- Syncing leads between HubSpot and Salesforce so marketing and sales see the same info.
- Notifying the right Slack channel when a deal stage changes in Salesforce, so executives stop asking for updates.
- Creating tasks or reminders in HubSpot or Salesforce when someone fills out a high-intent form.
Pro tip: Write out the “before” and “after” of your process on paper first. If you can’t explain it in one sentence, don’t automate it yet.
Step 2: Map Out Your Data Flows (Seriously, Don’t Skip This)
It’s boring but necessary. If you skip this, you’ll end up with duplicate records, missing info, or Slack spam.
- List your key objects: Contacts, companies, deals, leads, tickets—whatever’s important in your sales process.
- Map the direction: Does data go one way (HubSpot → Salesforce), both ways, or is it just about notifications?
- Decide on your “source of truth”: For each object, pick which system is the master. If you try to sync everything bi-directionally, you’ll regret it.
- Identify fields that need syncing: Don’t sync everything. Just what’s needed for the process.
Example:
When a new lead comes into HubSpot (from a form), create a lead in Salesforce—unless that email already exists there. Alert #sales in Slack if the lead score is over 70.
Step 3: Build a Simple Make Scenario (Start Small)
Make (formerly Integromat) is powerful, but it’s easy to overcomplicate things. Start with ONE scenario that does one thing well. Here’s how:
1. Trigger
Choose what sets things in motion. Some examples:
- New contact in HubSpot
- Opportunity stage change in Salesforce
- New message in a specific Slack channel
2. Filters & Conditions
Don’t skip filters. Otherwise, you’ll spam your team or create junk data.
- Only act if lead status is “Marketing Qualified”
- Only notify if deal value is over $10,000
- Ignore test/demo accounts
3. Actions
What should actually happen? Examples:
- Create or update a record in Salesforce
- Post a message in Slack with key info (but not every field)
- Update a HubSpot property
Pro tip: Use “search” modules before “create”—otherwise, you’ll get duplicates.
Step 4: Handle Errors and Edge Cases
Most automation horror stories come from edge cases nobody planned for.
- Duplicates: Use Make’s “search” modules to check if a record exists before creating.
- Failed API calls: Set up error handling and notifications so you know when something breaks.
- Field mismatches: Not every field maps 1:1 between platforms. Leave fields blank rather than forcing bad data.
What to ignore: Automating every single field or process. Start with the 80/20—what saves the most time or prevents the most errors?
Step 5: Set Up Slack Notifications (But Don’t Annoy People)
Everyone wants Slack alerts, until they’re getting 100 a day. Be surgical.
- Only notify for high-intent leads, closed-won deals, or critical errors.
- Use threads or dedicated channels for noisy automations.
- Include just enough context in the message—no wall of text, just the essentials and a link.
Pro tip: Add a “mute” or “unsubscribe” emoji workflow so folks can opt out if it’s too much.
Step 6: Monitor, Test, and Iterate
- Test with real data: Don’t just run Make’s built-in test—try it end-to-end with real leads or deals.
- Set up logging: Use Make’s built-in scenario run logs, but also consider posting errors to a private Slack channel.
- Review weekly: Stop broken automations from silently failing for months. Check logs and ask your users what’s actually helping.
What Works Well (And What Doesn’t)
Works: - Clear, single-direction syncs (e.g., HubSpot → Salesforce for leads) - Triggering Slack alerts for a few, high-value events - Automating simple, repeatable tasks
Doesn’t Work: - Trying to keep every field in sync, both ways - Automating processes that change every month - Slack notifications for every single update (burnout city)
Ignore: - Overly complex branching logic until you’ve nailed the basics - “Automate everything” mindsets—more isn’t better
Common Pitfalls to Dodge
- Not having admin access: You’ll need someone with permissions in all three platforms. Don’t wait until everything’s built to find out you’re blocked.
- API limits: Salesforce and HubSpot both have API call limits. If you’re moving a ton of data, you can hit these quickly.
- Security: Don’t post sensitive customer info in public Slack channels. Use private groups or DMs for anything confidential.
Keep It Simple, Ship, and Iterate
Most integrations fail because they try to do too much, too soon. Start simple. Automate one thing that actually saves time or solves a real problem. Test it. Get feedback. Tweak it. Then, and only then, add another scenario.
There’s no gold medal for the most complicated workflow. The real win is less manual work and fewer mistakes. Stick to that, and you’ll build a GTM stack that actually helps your team—without driving everyone nuts.