Step by step guide to syncing Salesforce contacts with Make workflows

So you want Salesforce contacts to sync automatically with other apps, and you’re eyeing Make to help you do it? Smart move. This guide is for admins, ops folks, and "accidental techies" who just want their contacts to flow without breaking the bank or their brains. We’ll get right to the point—no fluff, no sales pitch, just a step-by-step walkthrough you can actually use.

Why bother syncing Salesforce contacts with Make?

Let’s be real: Salesforce’s built-in integrations are clunky, and Zapier gets pricey fast. Make (formerly Integromat) is a solid middle ground. It’s visual, flexible, and, with some patience, will let you move data between Salesforce and pretty much anything else—Google Sheets, HubSpot, Mailchimp, you name it.

But, fair warning: Make isn’t magic. There’s a learning curve, quirks around field mapping, and some gotchas with Salesforce’s API limits. This guide helps you dodge the big headaches.

What you need before you start

You’ll need:

  • A Salesforce account with API access (Enterprise or higher, or Professional with API add-on)
  • A Make account (free tier is fine for testing)
  • Admin rights in both platforms
  • A clear idea of which way you want data to flow (Salesforce to another app, or both ways)

Pro tip: Don’t try to sync everything right off the bat. Start with one-way syncing of new or updated contacts. Two-way sync is a can of worms—tackle that later.

Step 1: Get your Salesforce API credentials

Make needs to talk to Salesforce through its API. Here’s how you get those credentials:

  1. Log in to Salesforce with admin privileges.
  2. Go to Setup (the gear icon).
  3. Search for App Manager in the Quick Find box.
  4. Click New Connected App.
  5. Fill in the basics (name, contact email).
  6. Under API (Enable OAuth Settings), check the box.
  7. Enter a Callback URL (use https://www.integromat.com/oauth/cb/salesforce2 if you’re using Make’s built-in Salesforce app).
  8. Select the following OAuth scopes:
  9. Access and manage your data (api)
  10. Perform requests on your behalf at any time (refresh_token, offline_access)
  11. Save the app and wait a few minutes for it to activate.

Write down your Consumer Key and Consumer Secret. You’ll need them for Make.

Step 2: Connect Salesforce to Make

Now, let’s hook up Salesforce to Make:

  1. Log in to your Make account.
  2. Create a new scenario (that’s what Make calls a workflow).
  3. Click the big plus (+) to add your first module.
  4. Search for Salesforce and select it.
  5. Choose a trigger, like Watch Records (for when a contact is created or updated).
  6. Click Add to create a new Salesforce connection.
  7. Enter your Salesforce credentials (Consumer Key, Consumer Secret, username, password, and security token if needed).
  8. Authorize the connection.

If you get authentication errors: Double-check your Salesforce user permissions and that your API credentials are correct. The Make docs are decent, but Salesforce errors are often cryptic—Google is your friend.

Step 3: Set up your trigger (watching Salesforce contacts)

This is where you tell Make: “Hey, watch my Salesforce contacts and do something when they change.”

  1. In your new scenario, set the Salesforce module to Watch Records.
  2. Pick the Contact object.
  3. Set the type of trigger:
  4. Created for new contacts only
  5. Updated for changes
  6. Both if you want all activity (more API calls)
  7. Set the Polling interval (how often Make checks Salesforce). Start with every 15 minutes. Faster means more API use and potential throttling.
  8. Optional but smart: Add filters so you’re not triggering on every tiny change (e.g., only sync if Email or Phone changes).

Pro tip: Salesforce has API call limits. If you’re on a lower-tier plan or have a busy org, keep polling intervals higher and filter aggressively.

Step 4: Set up your action (where contacts go)

This depends on what you’re syncing to—Google Sheets, Mailchimp, another Salesforce org, etc. The general process:

  1. Add a second module after your Salesforce trigger.
  2. Choose the app you want to receive the contact (e.g., Google Sheets, Mailchimp).
  3. Map the fields from Salesforce to the destination app. For example:
  4. Salesforce FirstName → Sheet column First
  5. Salesforce Email → Mailchimp Email Address
  6. Test the scenario with sample data.

Field mapping is the most tedious part. Field names don’t always match, and formats can be weird (e.g., dates, picklists). Don’t be afraid to use Make’s built-in “Set Variable” or “Text Formatter” modules to clean up data as it moves.

Step 5: Handle duplicates and updates

Contacts change—a lot. If you don’t want duplicates or weird overwrites, you need a strategy:

  • Deduplicate by Email: Most apps use email as a unique identifier. Set up a filter or search step to check if the contact already exists on the destination before creating a new one.
  • Update instead of create: Use Make’s search modules (e.g., “Search Rows” in Google Sheets) to find an existing record, then an “Update” module to change it.
  • Handle deletes: This gets messy. Most folks skip syncing deletes (removing a contact in Salesforce won’t zap it elsewhere automatically). If you must, build a separate scenario for that.

Honest take: Two-way sync sounds great, but it’s a pain. Start with one-way. Otherwise, you’ll end up chasing your tail with conflicts and overwrite issues.

Step 6: Test, test, test

Don’t just trust that it works—try it with real (but fake) data.

  • Create a test contact in Salesforce and see if it appears in your destination app.
  • Update the contact’s info and check that it syncs.
  • If you’re syncing back, change data in the destination app and see what happens.
  • Check the Make scenario logs for errors or skipped records.

Pro tip: Put yourself on the alert list for Make scenario failures. Nothing’s worse than finding out weeks later that your sync broke.

Step 7: Schedule and monitor

Once your scenario works, set it to run on a schedule (not just manually).

  • In Make, click the scheduling toggle to turn your scenario on.
  • Set notifications for errors or failed runs.
  • Keep an eye on your Make operations quota (especially on the free plan).

Don’t set it and forget it. Check on your sync at least weekly, especially after making changes to Salesforce layouts or fields.

What to ignore (for now)

  • Two-way sync: Wait until one-way works reliably.
  • Syncing every field: Only sync what you actually need. The more fields, the more things can break.
  • Real-time triggers: Make polls; it’s not instant. If you need true real-time, you’ll need to shell out for fancier tools.
  • Heavy-duty error handling: Start simple. Add complexity only when you hit real problems.

A few honest pros and cons

What works:

  • Make is way more flexible than most SaaS connectors.
  • You can connect Salesforce to just about anything.
  • It’s way cheaper than enterprise-grade integration platforms.

What doesn’t:

  • Setup is fiddly, especially for non-technical folks.
  • API limits in Salesforce can bite you if you’re not careful.
  • Field mapping is tedious and breaks if you change things in Salesforce.
  • Error handling is basic—don’t expect miracles.

Wrapping up: Keep it simple, improve as you go

You don’t need a computer science degree to sync Salesforce contacts with Make, but you do need patience and a willingness to tinker. Start small, sync just the essentials, and test like crazy. Most important: don’t try to automate everything on day one. Get a basic sync running, make sure it actually helps, and only then add more bells and whistles.

Good luck—and remember, nothing is ever really “set and forget” with integrations. But with a bit of care, you can make your data flow without losing your mind.