Salesforce integration services connect Salesforce to the systems that hold the rest of your revenue: the ERP that invoices, the billing tool that collects, the store that takes orders and the tool that runs delivery. Done well, a rep sees whether an account paid without asking finance, and a closed deal opens delivery work without retyping.
Integration work can be scoped as a large program. Most firms need three or four flows working: orders and invoices between Salesforce and NetSuite or Stripe, Shopify customers on the right account, and closed won deals that create Asana or Jira work. Benian builds them one at a time, each with a matching rule, an error path and a named owner.
Below: each common flow and what breaks in it, how to choose between an AppExchange connector, middleware and a direct API build, and how a project is scoped. Benian does not claim Salesforce partner status and publishes no price; cost depends on the number of flows, the sync direction and how clean your data is.
Signs Salesforce is out of step with the rest of the business
Reps ask finance whether a customer paid
Invoices and payments live in NetSuite or Stripe, so Salesforce shows a closed deal with no payment status.
Two records for the same customer
A Shopify buyer and a Salesforce contact share an email but not a record, so reports double count and sales calls a customer who already ordered.
Closed won stops at the sales team
Someone retypes deal details into Asana or Jira. Scope notes get dropped and kickoff waits on that person.
A connector nobody watches
It syncs most records. The rejected ones pile up in a log nobody reads until quarter end.
What a Salesforce integration needs to define first
Every Salesforce CRM integration rests on four decisions per flow. If two systems both think they own a field, they overwrite each other on every sync.
- System of record: which system owns each field. Usually Salesforce owns accounts and opportunities, the ERP or billing tool owns invoices and payment status, and the store owns orders.
- Matching key: how a record finds its twin. An External ID field holding the other system's ID beats matching on name or email.
- Trigger and direction: the event that starts the sync, such as Closed Won or a paid invoice, and whether data flows one way or both.
- Exception owner: the named person who gets a failed record, and how fast they act.
ERP and billing: NetSuite and Stripe
The usual NetSuite and Salesforce integration flow is quote to cash. When an opportunity closes, the integration creates or updates the NetSuite customer, creates a sales order from the line items and writes the NetSuite IDs back. When NetSuite posts the invoice and records payment, status and balance flow back to the account. Any ERP integration with Salesforce has the same shape.
The failure case is item mapping: a product or discount line with no matching NetSuite item, so the order is rejected. The fix is a maintained product mapping table and a rule that rejected orders go to a finance queue with the reason attached.
A Stripe integration with Salesforce runs the other way. Stripe sends events such as a successful charge, a failed payment or a cancelled subscription, and the integration writes them to the matching account. Events can arrive twice or out of order, so the build records processed events and never lets an older one overwrite a newer status. A failed payment also creates a task for the account owner.
Commerce: Salesforce and Shopify integration
A Salesforce and Shopify integration fits when online buyers also talk to sales, such as wholesale or repeat business accounts. A new order finds the Salesforce contact by email, creates one if none exists, links it to the account and records the order on a custom object or activity.
The failure case is identity. Guest checkouts, shared company emails and typos create duplicates fast. Decide whether new emails create contacts automatically or go to a review list. A high volume store may send a daily summary per customer instead of every order.
Delivery handoff: Asana and Jira from closed won deals
An Asana Salesforce integration usually means: when an opportunity reaches Closed Won, create a project from a template with client, scope summary, start date and owner, and post the project link back on the opportunity.
A Jira and Salesforce integration for support works on cases: an escalated case creates a Jira issue, the issue key is stored on the case, and resolving the issue updates the case so the agent can reply. Keep internal engineering comments out of the customer facing case.
The failure case for both is the reopened deal or edited case. Store the created project or issue ID on the Salesforce record and check it before creating anything, or a deal that closes twice gets two projects.
Sales tools: LinkedIn, Zoom, Mailchimp and Intercom
These vendors publish their own Salesforce apps, so first check whether the app covers your flow. Often the work is field mapping, not a build. Build custom only when the app lacks a rule you need or writes data where reports do not read it.
- LinkedIn Salesforce integration: usually through Sales Navigator's CRM features, which link profiles to records and log activity. Check what your tier includes first.
- Salesforce Zoom integration: logs meetings against contacts and opportunities. Decide what happens with attendees not yet in Salesforce.
- Salesforce integration with Mailchimp: syncs selected contacts to an audience and brings activity back. Unsubscribes must reach Salesforce, or the next sync can re-add the person.
- Intercom Salesforce integration: links conversations to leads and contacts. Decide whether chats create leads, or the CRM fills with anonymous visitors.
AppExchange connector, middleware or custom API build
An AppExchange connector or vendor app is the fastest start when your flow matches its design. Middleware such as MuleSoft, which Salesforce owns, or a workflow tool such as n8n lets you shape each step. A direct API build is code for exactly your rules.
Our usual advice: vendor app for standard flows like Mailchimp or Zoom, a workflow tool for flows with rules and exceptions like NetSuite orders or closed won handoffs, code only for very high volume or unusual logic. Benian builds in accounts you own, for example n8n in your own account with credentials you hold, so the flows keep running if you stop working with us.
API limits, error handling and monitoring
Salesforce sets a daily API call allowance per org, based on edition and licenses, shared by every connected tool. An integration that polls every minute or updates records one at a time can exhaust it. Good builds react to events, batch updates and use the Bulk API for large loads such as a backfill.
Every flow needs a visible error path: failed records go to a queue with the record link and reason, timeouts retry automatically, and a weekly count comparison catches silent drift. Track records synced, records failed, time to fix and duplicates created. If failures do not fall after the first weeks, fix the mapping rules.
When not to hire anyone for this
If a vendor app covers your flow and your fields are standard, install it, map fields carefully and test with a few records. If your Salesforce data is badly duplicated, clean it first, because an integration copies the mess. For a full implementation or org redesign, a Salesforce consulting partner fits better.
Three ways to build a Salesforce integration
| Approach | Best when | Watch out for |
|---|---|---|
| AppExchange connector or vendor app | Your flow is standard and the app writes data where reports read it | Rigid mapping, rejected records hidden in a log |
| Middleware or workflow tool such as MuleSoft or n8n | Flows carry rules, exceptions or approvals across systems | Needs an owner who monitors it; check how cost grows with volume |
| Direct API build | Very high volume or logic no tool supports | You maintain the code as either API changes |
How a Salesforce integration project is scoped
- List the flows. Name each as a trigger and a result, such as opportunity closes, sales order appears in NetSuite. Rank by manual work or missed revenue.
- Map fields and owners. Set the system of record for every field, the matching key and the failure owner.
- Check data quality. Sample both systems for duplicates, missing IDs and unmapped products.
- Choose a method per flow. Vendor app, workflow tool or code, with the reason written down.
- Test edge cases in a sandbox. Reopened deals, duplicate events, rejected items and deleted records. Go live one flow at a time and watch its error queue.
- Hand over. Field maps, error paths and admin access, so anyone can maintain each flow.