Zum Hauptinhalt springen
Produktdetails werden auf Englisch angezeigt. Übersetzungen folgen in Kürze.
ERPNext Salesforce Two-Way Sync — A build-to-order bi-directional connector that keeps Salesforce and ERPNext in step across  — 1/1Beispielhafte Vorschau

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.

Was ist 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.

Hauptfunktionen

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
ERPNext→Salesforce push is event-driven via `hooks.py` doc events (`on_update`, `on_submit`) that enqueue `frappe.enqueue` background jobs — no UI blocking
Salesforce→ERPNext pull runs on `scheduler_events` cron polling the REST/Bulk API by last-modified watermark, with optional Platform Events / Change Data Capture subscription
Salesforce Id and last-modified stamp stored in custom fields on each ERPNext record for reliable cross-system matching and duplicate prevention
Idempotent upserts against a Salesforce External Id field and ERPNext record match, so retries and overlapping runs never create duplicate records
Field-level conflict resolution per mapping: last-writer-wins by modified timestamp, designated master system, or hold-for-review parked in the sync log
`Salesforce Sync Log` DocType capturing every attempt, direction, payload hash, and outcome, with one-click retry of failed rows via a whitelisted method
Order push to ERPNext that converts a won `Opportunity`/`Order` into a draft `Sales Order` with mapped line items, pricing, and customer, ready for review before submit
Dedicated Salesforce Sync role profile and role-based DocType permissions gating who can edit settings, mappings, or replay syncs
Whitelisted Frappe REST API methods for manual full/incremental resync and single-record push, callable from scripts or a button on the record
Built and tested for Frappe/ERPNext v15 and v16 against a Salesforce sandbox and ERPNext staging before any production cutover

Auf Bestellung gebaut, komplett für Sie erledigt

Keine Selbsteinrichtung — eine funktionierende App, die von ECOSIRE erstellt, installiert und betreut wird.

  1. 1

    Sie bestellen

    Starten Sie mit einem einmaligen Entwicklungspreis. Den Umfang legen wir beim Kickoff gemeinsam fest.

  2. 2

    Wir bauen & installieren

    ECOSIRE erstellt, konfiguriert und installiert sie auf Ihrem ERPNext.

  3. 3

    Go-live + Support

    Sie gehen in etwa einer Arbeitswoche live, mit zwei Wochen Go-live-Support. Fehler im von uns gelieferten Code beheben wir kostenlos.

Technische Spezifikationen

ERPNext-Kompatibilität
—
Lizenz
Lizenz muss bestätigt werden
Python-Anforderung
Python 3.10+
Datenbank
MariaDB 10.6+

Über dieses Produkt

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.

Was Sie bekommen

  • 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

Für wen das ist

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.

Wie ERPNext Salesforce Two-Way Sync im Vergleich abschneidet

KriteriumECOSIREBenutzerdefinierter BuildKonkurrentERPNext nativ
Bi-directional syncTrue two-way: event-driven push plus scheduled pull with conflict resolutionPossible but you design both directions and the reconciliation logic yourselfOften one-directional or shallow; deep two-way rarely configurableNo Salesforce sync at all in ERPNext core
Field mapping control`Salesforce Sync Mapping` DocType: per-field, per-direction, with transformsHard-coded in scripts; changing a mapping means a code changeFixed or limited mapping UI, hard to fit your objectsNone
Conflict resolutionPer-field: last-writer-wins, master system, or hold-for-reviewWhatever you build; usually last-write silently overwritesTypically last-write-wins with no review optionN/A
Duplicate preventionIdempotent upserts matched on Salesforce Id + External IdDepends on the matching keys you implement and testVaries; mismatches often create duplicate customers/ordersN/A
Auditability`Salesforce Sync Log` DocType with per-row outcome and one-click retryOnly if you build logging and a retry pathBasic logs, retry often manual or absentNone
ArchitectureProper Frappe app: DocTypes, hooks, whitelisted methods, scheduler jobsQuality depends on the developer; risk of client-script hacksThird-party app you cannot fully inspect or extendN/A
Ownership & supportFull source + git handover, docs, training, post-go-live support windowYou own it but also own all future fixesVendor lock-in; support and roadmap out of your controlCommunity/self-support only
Version fitBuilt and tested for Frappe/ERPNext v15 and v16 and your Salesforce API versionTied to whatever versions you targeted at build timeMay lag ERPNext or Salesforce version changesN/A

Häufig gestellte Fragen zu 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.

Angebot anfordern

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

Angebot anfordern

Beschreiben Sie Ihre Anforderungen an ERPNext Salesforce Two-Way Sync, und wir senden Ihnen Preise, Lizenzoptionen und ein maßgeschneidertes Angebot – in der Regel innerhalb eines Werktags.

Keine Zahlung jetzt. Dies sendet eine Angebotsanfrage an unser Team – wir melden uns per E-Mail mit Preisen und nächsten Schritten.