If you’re wrangling deals in Salesforce but building quotes or sales docs in Octavehq, you know the pain: copy-pasting info, chasing updates, and wondering which version is right. This guide walks you through integrating the two so you can ditch busywork, stop hunting for files, and actually trust your deal pipeline. If you’re in sales ops, admin, or just the unofficial “person who makes things work,” this is for you.
Why bother integrating Octavehq and Salesforce?
Let’s keep it real. Salesforce is the backbone for customer info, but its document tools are clunky. Octavehq shines at building slick sales docs and proposals, but it’s not where your pipeline lives. Integrating them means:
- Data flows between systems, so less manual entry (and fewer mistakes).
- Sales reps stay in their workflow, not toggling between tabs all day.
- You can track real doc engagement, not just email opens.
But: don’t expect magic. Integration won’t fix messy processes or bad data. Start simple, automate only what’s proven, and expect some trial and error.
What you’ll need before you start
- Admin access to both Salesforce and Octavehq.
- A test Salesforce environment (trust me — don’t run this in production first).
- Basic understanding of Salesforce Objects (Opportunities, Contacts, etc.).
- A clear idea of which data you want to sync (more on this below).
Step 1: Map out what you actually want to sync
Here’s where most folks get tripped up. Just because you can sync everything doesn’t mean you should.
What’s worth syncing?
- Opportunity details: deal name, stage, amount, close date.
- Account info: company name, billing address.
- Contact info: who’s signing, who’s approving.
- Proposal/quote status: sent, viewed, signed, etc.
What to skip: Internal Salesforce fields, old notes, custom fields nobody uses, or anything you don’t actually need in your docs or reporting. More data = more headaches.
Pro tip: Start with one or two key fields. You can always add more later.
Step 2: Get your Salesforce environment ready
Create a connected app (if needed)
Some Octavehq integrations use Salesforce’s API, which means you’ll need a connected app. If your Octavehq plan supports direct Salesforce integration, it’ll walk you through this, but here’s the gist:
- Go to Setup > App Manager in Salesforce.
- Click New Connected App.
- Give it a name (e.g., “Octavehq Integration”).
- Enable OAuth settings. Add the right callback URL (Octavehq will tell you what to use).
- Select OAuth scopes, usually:
- Access and manage your data (api)
- Perform requests on your behalf at any time (refresh_token, offline_access)
- Save, then wait a few minutes for Salesforce to process.
Keep the Consumer Key and Consumer Secret handy — you’ll need them in Octavehq.
Check field-level security
If Octavehq can’t see a field, it can’t sync it. Make sure the integration user in Salesforce has access to all the fields you care about.
Step 3: Set up Octavehq to talk to Salesforce
Log into Octavehq as an admin. Go to your integrations or settings area and look for Salesforce.
- Connect your Salesforce account: You’ll be prompted for the credentials or OAuth info you set up above.
- Choose your Salesforce environment: Sandbox for testing, production when you’re ready.
- Map your fields: This is where you link Octavehq placeholders (like {{Opportunity.Amount}}) to Salesforce fields.
Don’t just map everything. Focus on what your sales team really needs — a bloated doc full of fields nobody reads is just noise.
Step 4: Test the connection (and break things on purpose)
Before rolling this out, test with a few dummy records:
- Create a test Opportunity in Salesforce.
- Build a doc in Octavehq using the mapped fields.
- Push data back and forth:
- Does Octavehq pull in the right info from Salesforce?
- If someone updates the Opportunity, does the doc refresh?
- Does the status of the doc (sent/viewed/signed) update in Salesforce?
Try to break it. Change field values, delete data, use weird characters. It’s better to find bugs now than with a real customer.
Step 5: Automate (but don’t go overboard)
Octavehq can trigger actions back in Salesforce, like updating an Opportunity stage when a doc is signed. This is handy, but don’t set up a Rube Goldberg machine.
- Start with essentials: update Opportunity status, log when a doc is sent or signed.
- Avoid auto-updating fields that humans should control (like deal amount).
- Use notifications sparingly. Nobody reads 200 “Doc Viewed” emails a week.
Pro tip: Document your automations somewhere your team can find them. “Surprise automations” are how things break.
Step 6: Train your team (with real use cases, not theory)
Show reps how the integration works with real deals — not just screenshots. Focus on:
- How to pull up the right doc from within Salesforce.
- What fields auto-fill, and which need manual input.
- How Octavehq tracks views/signatures, and where that shows up in Salesforce.
- Who to call when something breaks (and it will, sometimes).
Skip the hour-long training slides. A five-minute video beats a 20-page manual.
What works (and what doesn’t)
What works well
- Auto-filling sales docs: No more copy-paste errors or out-of-date info.
- Tracking engagement: See when a prospect views your doc, right from Salesforce.
- Faster turnaround: Less bouncing between tools, fewer missed steps.
What doesn’t (or isn’t worth it)
- Overcomplicating your field mappings: More fields = more things to break. Start small.
- Relying on integration for process discipline: If your team skips steps now, tech won’t fix that.
- Assuming “one-click” anything: There’s always some manual review, especially for complex deals.
Common pitfalls to avoid
- Not involving end users early: If you set up the “perfect” integration but reps hate it, it fails.
- Ignoring permissions: If the integration user can’t see a field, nothing syncs.
- Testing only happy paths: Real data is messy. Test with bad data, missing info, and oddball edge cases.
Wrapping up: Keep it simple, iterate as you go
Salesforce and Octavehq can play nicely together — but only if you keep your setup focused. Start with your must-haves, get feedback from actual users, and add complexity only when it solves a real problem. Don’t chase “seamless integration” for its own sake; chase fewer headaches and more closed deals. And when in doubt, remember: simpler is better.