- Home
- Apps
- Specialized Solutions
- ERPNext Salesforce Two-Way Sync
Illustrative previewA build-to-order bi-directional connector that keeps Salesforce and ERPNext in step across accounts,
contacts, opportunities, and orders.
ECOSIRE scopes, builds, installs, and supports it so your sales team lives in Salesforce while operations and invoicing run in ERPNext without double entry.
What is ERPNext Salesforce Two-Way Sync?
A build-to-order bi-directional connector that keeps Salesforce and ERPNext in step across accounts, contacts, opportunities, and orders. ECOSIRE scopes, builds, installs, and supports it so your sales team lives in Salesforce while operations and invoicing run in ERPNext without double entry. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $999.00 USD; request a quote for a scoped proposal.
Key Features
Built to order, done for you
No DIY setup — a working app, built, installed and supported by ECOSIRE.
- 1
You order
Start with a one-time build price. We scope it with you at kickoff.
- 2
We build & install
ECOSIRE builds, configures and installs it on your ERPNext.
- 3
Go live + support
You go live in about one working week, with two weeks of go-live support. Defects in the code we deliver are fixed free of charge.
Technical Specifications
- ERPNext Compatibility
- —
- License
- Licence confirmation required
- Python Requirement
- Python 3.10+
- Database
- MariaDB 10.6+
About this Product
Companies that sell in Salesforce but run the business in ERPNext keep paying the same tax twice: a deal closes in Salesforce, and someone re-keys the account, the contacts, and the line items into ERPNext to raise a Sales Order and invoice. ERPNext core has no Salesforce provider — no Salesforce Settings DocType, no OAuth handshake against the Salesforce REST API, no listener for Salesforce Platform Events, and nothing that maps a Salesforce Opportunity to an ERPNext Quotation or Sales Order. Teams paper over the gap with CSV exports, a one-directional Zapier zap, or a nightly script that silently overwrites whichever side was edited last. Records drift, close dates disagree, and finance stops trusting either system. This is where ERPNext native runs out of road.
ECOSIRE builds a proper Frappe app — a real installable app in your bench, not a pile of client scripts — that treats Salesforce as a first-class integration. We add a Salesforce Settings single DocType holding the Connected App consumer key/secret, instance URL, and API version in encrypted password fields, with a Salesforce OAuth 2.0 token exchange (JWT bearer or web-server flow) and automatic refresh handled server-side. A Salesforce Sync Mapping DocType lets an admin declare, per object, how a Salesforce Account maps to an ERPNext Customer, a Contact to a Contact, an Opportunity to a Quotation/Opportunity, and an Order to a Sales Order — including per-field mappings, value transforms, and which side is the source of truth for each field. Every synced record stores its Salesforce Id and last-modified stamp in custom fields so the connector can match records across systems instead of creating duplicates.
Technically, the two directions are handled differently on purpose. ERPNext-to-Salesforce is event-driven: hooks.py doc events (on_update, on_submit) enqueue a background job via frappe.enqueue that pushes the change through the Salesforce REST API (sObject upsert against your External Id), so submitting a Sales Order in ERPNext writes the matching Order back to Salesforce without blocking the user. Salesforce-to-ERPNext runs on a scheduler_events cron that polls the Salesforce REST/Bulk API for records changed since the last watermark (or subscribes to Platform Events / CDC where available), then upserts into ERPNext inside a single transaction. A Salesforce Sync Log DocType records every attempt, payload hash, and outcome, and failed rows are retriable from a whitelisted method exposed on the Frappe REST API. Field-level conflict resolution is configurable per mapping — last-writer-wins by modified timestamp, a designated master system, or hold-for-review that parks the clash in the log for a human — so a rep editing a phone number in Salesforce and ops editing it in ERPNext never silently clobber each other. Permissions are enforced through a dedicated role profile and role-based DocType permissions so only authorised users touch the settings or replay failed syncs.
Because this is build-to-order, you are not downloading a generic app and hoping it fits. We start from your actual Salesforce org and ERPNext instance: which objects and fields matter, which side owns each field, how you want opportunities to become quotations or orders, and what your dedup rules are. We build the connector for Frappe/ERPNext v15 and v16, test it end-to-end against a Salesforce sandbox and an ERPNext staging site, and hand over source you own. Typical delivery is one working week from confirmed scope, and we support it after go-live so schema or Salesforce API-version changes never break the bridge silently.
What you get
- Installable Frappe app source code for your version (v15 and/or v16), building on your ERPNext bench with `bench get-app` / `bench install-app`
- Guided installation and configuration on your instance: Connected App wiring, OAuth setup, and initial mapping configuration
- Technical documentation: DocType reference, mapping schema, hooks and scheduler behaviour, and the Salesforce API scopes required
- End-user guide plus a live training session for your sales-ops and finance users covering resync, conflict review, and the sync log
- Post-go-live support window for defect fixes and Salesforce API-version / schema adjustments
- UAT on a staging site against a Salesforce sandbox, with a documented rollback plan before production cutover
- Git repository handover with full commit history so you own and can extend the connector
- Field-mapping workbook capturing the agreed object/field mappings and source-of-truth rules from the scoping call
Who this is for
RevOps / Sales Operations Lead
Owns the Salesforce org and wants reps to stay in Salesforce while accounts, opportunities, and closed orders flow into ERPNext automatically. Needs configurable field mapping and confidence that nothing gets double-keyed or silently overwritten.
ERPNext Administrator / Frappe Developer
Runs the bench and will maintain the app after handover. Wants a proper Frappe app with clean DocTypes, hooks, whitelisted methods, and scheduler jobs — not client-script hacks — plus the source and docs to extend it.
Finance / Order-to-Cash Manager
Needs won deals in Salesforce to become accurate ERPNext Sales Orders and invoices without re-keying line items. Cares about matching, dedup, and an auditable sync log to trust the numbers on both sides.
Head of Sales
Wants a single trustworthy pipeline where Salesforce close dates, amounts, and account data agree with what operations sees in ERPNext, so forecasting and fulfilment stop diverging.
How ERPNext Salesforce Two-Way Sync Compares
| Criterion | ECOSIRE | Custom Build | Competitor | ERPNext Native |
|---|---|---|---|---|
| Bi-directional sync | True two-way: event-driven push plus scheduled pull with conflict resolution | Possible but you design both directions and the reconciliation logic yourself | Often one-directional or shallow; deep two-way rarely configurable | No Salesforce sync at all in ERPNext core |
| Field mapping control | `Salesforce Sync Mapping` DocType: per-field, per-direction, with transforms | Hard-coded in scripts; changing a mapping means a code change | Fixed or limited mapping UI, hard to fit your objects | None |
| Conflict resolution | Per-field: last-writer-wins, master system, or hold-for-review | Whatever you build; usually last-write silently overwrites | Typically last-write-wins with no review option | N/A |
| Duplicate prevention | Idempotent upserts matched on Salesforce Id + External Id | Depends on the matching keys you implement and test | Varies; mismatches often create duplicate customers/orders | N/A |
| Auditability | `Salesforce Sync Log` DocType with per-row outcome and one-click retry | Only if you build logging and a retry path | Basic logs, retry often manual or absent | None |
| Architecture | Proper Frappe app: DocTypes, hooks, whitelisted methods, scheduler jobs | Quality depends on the developer; risk of client-script hacks | Third-party app you cannot fully inspect or extend | N/A |
| Ownership & support | Full source + git handover, docs, training, post-go-live support window | You own it but also own all future fixes | Vendor lock-in; support and roadmap out of your control | Community/self-support only |
| Version fit | Built and tested for Frappe/ERPNext v15 and v16 and your Salesforce API version | Tied to whatever versions you targeted at build time | May lag ERPNext or Salesforce version changes | N/A |
Frequently Asked Questions about ERPNext Salesforce Two-Way Sync
How long until it is live, and how does build-to-order delivery work?
This is build-to-order: we do not ship a generic download. After a short scoping call to confirm which objects, fields, and source-of-truth rules matter, typical delivery is one working week from confirmed scope. We build the Frappe app, test it against a Salesforce sandbox and an ERPNext staging site, run UAT with you, then cut over to production with a rollback plan.
How do you get support and updates after go-live?
Every build includes a post-go-live support window for defect fixes and for adjustments when Salesforce changes its API version or you change your schema. Because you receive the full source and git repository, your own Frappe developer can also extend it; we can additionally quote an ongoing support retainer if you want us to own maintenance.
Is the sync genuinely two-way, and how are edit conflicts handled?
Yes. ERPNext→Salesforce changes are pushed on `hooks.py` doc events via background jobs; Salesforce→ERPNext changes are pulled on a scheduler cron (or Platform Events/CDC where available). Conflicts are resolved per field mapping — last-writer-wins by modified timestamp, a designated master system, or hold-for-review that parks the clash in the sync log for a human to decide.
Will it create duplicate customers or orders?
No. Every synced record stores its Salesforce Id and a last-modified stamp in custom fields, and all writes are idempotent upserts matched on an External Id and existing ERPNext record. Retries and overlapping runs update the existing record instead of creating a new one.
Which Frappe/ERPNext and Salesforce versions do you support?
We build and test for Frappe/ERPNext v15 and v16. On the Salesforce side we authenticate with OAuth 2.0 (JWT bearer or web-server flow) against the Salesforce REST/Bulk API using a Connected App, pinned to a specific API version that we keep current as part of support.
What access do you need in Salesforce?
A Connected App with API-enabled OAuth scopes and a service/integration user with permission on the objects in scope (Account, Contact, Lead, Opportunity, Order, or whichever you select). Credentials are stored encrypted in the `Salesforce Settings` DocType; nothing sensitive lives in client-side scripts.
Can we control exactly which fields sync and in which direction?
Yes. The `Salesforce Sync Mapping` DocType lets an admin declare, per object, which fields map to which, apply value transforms, and set which system owns each field. You can sync some fields both ways, others one way, and exclude the rest.
Related Modules

ERPNext Qatar VAT & E-Invoicing Readiness
A build-to-order ERPNext app that aligns your tax reporting to Qatar's General Tax Authority requirements and prepares your invoicing for the coming e-invoicing mandate. ECOSIRE scopes, builds, installs, and supports it — this is not an off-the-shelf download.

ERPNext Stripe Tax & Invoicing Suite
A build-to-order Frappe app that wires Stripe Tax rate calculation and Stripe hosted invoices directly into ERPNext, with tax registration tracking and automated payment reconciliation. ECOSIRE builds, installs, and supports it on your bench.

ERPNext Subscription & Recurring Billing Pro
A build-to-order ERPNext app that extends native Subscription with usage metering, proration, automated dunning, and revenue recognition. ECOSIRE scopes, builds, installs, and supports it on your bench — this is not an instant Marketplace download.
ERPNext Salesforce Two-Way Sync
A build-to-order bi-directional connector that keeps Salesforce and ERPNext in step across accounts, contacts, opportunities, and orders. ECOSIRE scopes, builds, installs, and supports it so your sales team lives in Salesforce while operations and invoicing run in ERPNext without double entry.
- First-class `Salesforce Settings` single DocType storing Connected App consumer key/secret, instance URL, and API version in encrypted password fields with a test/live toggle
- Salesforce OAuth 2.0 authentication (JWT bearer or web-server flow) with server-side access-token refresh, so no long-lived credentials sit in client code
- Bi-directional object sync: Salesforce `Account`↔ERPNext `Customer`, `Contact`↔`Contact`, `Lead`↔`Lead`, `Opportunity`↔`Quotation`/`Opportunity`, and `Order`↔`Sales Order`
- Configurable `Salesforce Sync Mapping` DocType for per-object, per-field mapping, value transforms, and declaring the source-of-truth side for each field
