If you’re spending hours every week updating Salesforce by hand, or you’re tired of your GTM (go-to-market) team squabbling over whose spreadsheet is “the source of truth,” this guide is for you. I’ll show you how to wire up Spoke with Salesforce so your data flows where it should—without you babysitting it.
This isn’t a hype piece. I’ll walk through what works, what trips people up, and a few things you can just skip. If your job relies on clean, up-to-date CRM records, you’ll want to keep reading.
Why bother syncing Spoke and Salesforce?
Let’s get something out of the way: syncing tools is only worth it if it saves you time or headaches. Here’s what actually gets better when Spoke and Salesforce talk to each other:
- No more double entry: Update a record in one, it shows up in the other.
- Fewer “where’s the latest info?” emails: Everyone’s looking at the same data.
- Less manual cleanup: Automation catches small errors before they become big ones.
But syncing isn’t a magic fix. If your data’s already a mess, shoveling it between tools just spreads the mess around. Get your basics right first.
Step 1: Get your groundwork sorted
Before you even touch the integration:
1.1. Clean up your data
- Duplicates: Merge or delete obvious duplicates in both platforms.
- Field formats: Make sure the data types (dates, emails, phone numbers) match up. If Salesforce expects an email and Spoke has “Call me maybe,” fix it now.
- Access rights: Make sure you have admin rights in both Spoke and Salesforce. You’ll need them.
Pro tip: If you’re not sure what’s clean, export a small sample and check it by hand. It’s tedious, but it’ll save you hours later.
1.2. Map out what you actually need to sync
Don’t just sync everything because you can. Decide:
- Which objects? (Leads, Contacts, Accounts, Opportunities, Custom Objects?)
- Which fields? (You probably don’t need every single field. Focus on what teams use.)
- Which direction? (One-way or two-way? Think about which system should “win” in conflicts.)
Write this down. You’ll thank yourself.
Step 2: Connect Spoke to Salesforce
Assuming you’re using Spoke’s out-of-the-box Salesforce integration (if you’re not, skip to DIY options below), here’s what to do:
2.1. Log into both platforms
- Open Spoke in one tab, Salesforce in another.
- Double-check you’re in the right environment (sandbox vs. production). Don’t nuke your live data by mistake.
2.2. Find the Salesforce integration in Spoke
- In Spoke, go to Settings > Integrations.
- Look for “Salesforce” and click “Connect” or “Add Integration.”
2.3. Authorize access
You’ll be sent to a Salesforce login screen. Use an admin account. Grant the requested permissions—yes, it’ll ask for a lot. If you’re squeamish, check what’s being requested. Most integrations want:
- Read/write access to objects you’re syncing
- Permission to pull metadata (so Spoke knows your Salesforce structure)
- Sometimes, access to modify custom fields
If your org has strict security, you might need IT to whitelist Spoke in Salesforce’s “Connected Apps.”
2.4. Configure your sync rules
This is where your earlier mapping comes in handy. In Spoke:
- Pick which Salesforce objects you want to sync (e.g., Leads, Contacts).
- Map Spoke fields to Salesforce fields. Watch out for:
- Data types: Don’t map a text field to a date field.
- Required fields: If Salesforce requires a field, make sure Spoke can provide it.
- Set sync direction:
- One-way: Updates flow only from Spoke to Salesforce (or vice versa).
- Two-way: Changes in either system update the other. This is powerful, but also riskier for accidental overwrites.
Pro tip: Start with one object (like Leads) and get that working before you turn on everything.
Step 3: Test with a sandbox (don’t skip this)
I know, everyone says “test in sandbox,” but here it actually matters. You don’t want to spray bad data all over your pipeline.
- Set up the integration using your Salesforce sandbox.
- Push a handful of test records from Spoke to Salesforce and back.
- Check for:
- Field mapping errors (data ends up in the wrong place)
- Missing required fields
- Data type mismatches
- Duplicates (are you creating new records or updating existing ones?)
If you see weirdness, fix your mappings or adjust field settings before you try this in production.
Step 4: Go live (carefully)
Once you’re happy with sandbox testing:
- Switch your connection to the Salesforce production environment.
- Start with a small batch of syncs. Pick a non-critical object or subset (like just new leads from this week).
- Monitor for errors. Most platforms will generate error logs—read them. Fix any issues before you open the floodgates.
Reality check: The first sync will probably catch a bunch of small issues you missed. That’s fine—just fix and move on.
Step 5: Monitor and maintain
Integrations aren’t “set and forget.” Keep an eye on:
- Sync failures: Set up alerts if possible. If something breaks, you want to know before sales does.
- Field changes: If someone adds new fields in Salesforce or Spoke, you’ll need to update your mappings.
- User feedback: Encourage your team to call out missing or wrong data. They’re usually the first to spot issues.
Review your integration every quarter or so. It’ll save you a world of hurt when something inevitably changes.
What works, what doesn’t, what to skip
What works:
- Out-of-the-box integrations: If you can use Spoke’s built-in Salesforce connector, do it. It’s faster and gets regular updates.
- Incremental rollout: Sync one object at a time, fix issues, then expand.
- Documentation: Keep a simple doc of what’s mapped and why. Future you (or your replacement) will love you for it.
What doesn’t:
- Trying to sync everything: You don’t need every field and object. Start with what matters.
- Ignoring error logs: Problems don’t go away if you don’t look at them.
- Over-customizing: Custom scripts and middleware sound cool until they break. Stick to standard features unless you really need something custom.
What to skip:
- Third-party “integration platforms” unless you have unique needs: Most companies don’t need Zapier, Mulesoft, or Workato here unless Spoke’s native integration is missing something crucial.
- Real-time sync for everything: Near real-time (every few minutes) is fine for most sales teams. Real-time adds complexity and breaks more often.
Troubleshooting common headaches
- Duplicates popping up: Usually a mapping or deduplication setting is off. Make sure you’re matching on a unique field (like email or Salesforce ID).
- Field values not syncing: Double-check that the fields are actually mapped and that data types match.
- Permissions errors: Make sure Spoke’s integration user in Salesforce has the right permissions for all synced objects and fields.
- Data overwrites: If two-way sync is on, make sure you set “source of truth” rules. Otherwise, last update wins (which can get messy).
If you’re stuck, check both platforms’ help docs and reach out to support—sometimes bugs crop up on either side.
DIY integrations: When you need something special
If you need to sync custom objects or do something Spoke’s built-in connector doesn’t support, you’ve got options:
- Salesforce APIs: Spoke and Salesforce both have APIs. You can write scripts to move data, but it’s more work and more ways to break stuff.
- Middleware: Tools like Zapier, Tray.io, or Workato can bridge gaps, but add cost and complexity.
- Custom code: If you go this route, document everything and build in error handling. Don’t leave it to one engineer who then quits.
For most teams, the built-in integration does the trick. Go custom only if you really need to.
Keep it simple, iterate as you go
The best integrations are the ones you barely notice. Start simple. Sync just what matters. Get the basics right, then add more if you need it.
Don’t stress about being perfect on day one. If you keep your setup straightforward and check in regularly, you’ll avoid most of the big headaches.
And if you run into trouble? Take a breath, check your mappings, and remember: you’re not the first person to fight with CRM syncing. It gets easier.
Good luck—and enjoy getting those hours of your life back.