Connecting Salesforce to a practice management system means choosing one system of record per field, syncing through Salesforce’s REST or Bulk API (or your PM system’s API), and building the retries, deduplication and monitoring that keep the two from disagreeing. Done as a proper integration rather than a Zap, it takes four to ten weeks and costs $15,000 to $45,000 for the first sync. The payoff is that staff stop re-typing the same patient, provider or client into two screens.
This page covers the patterns that hold up, the decisions to make before writing code, and the mistakes that produce two systems that both look right and never match.
The integration fails or succeeds on this one table, written before any code. For every field that exists in both systems, name the owner:
| Field |
Owner |
Direction |
Notes |
| Provider / patient demographics |
Practice management |
PM → Salesforce |
PM has the verified record; Salesforce shows it |
| Credentialing or case status |
Practice management |
PM → Salesforce |
Status drives client-facing dashboards |
| Sales stage, account owner, notes |
Salesforce |
Salesforce → PM (or stays) |
PM rarely needs sales fields |
| Documents |
Practice management or a document store |
Links both ways |
Store once; sync the pointer, not the file |
| Contact email and phone |
One of them, decided per field |
One way |
Two-way sync on contact fields is where loops start |
Two-way sync on the same field is the most common request and the most common source of silent data loss. Pick an owner; if both sides need to edit, make the integration write to the owner and let the other side read.
1. Scheduled sync (most practices). A job runs every 5–15 minutes, pulls changed records since the last run from the owner, and upserts them into the other system on an external ID. Simple, observable, easy to re-run. Latency is minutes, which is fine for dashboards and credentialing progress.
2. Event-driven. Salesforce Platform Events or outbound messages, or webhooks from the PM system, push each change as it happens. Latency is seconds. The cost is in handling out-of-order and duplicate events and in what happens when the receiver is down. Use it when a status change has to appear in the other system within a minute.
3. Read-through (no copy). Salesforce shows PM data live through an API call at view time (Salesforce Connect or a custom Lightning component). Nothing is duplicated, nothing drifts. Right when the data is only ever viewed in Salesforce and the PM system’s API is fast enough. This is the pattern behind nCred’s client portal: dashboards pull live credentialing progress from Salesforce so clients see the same status the team sees.
Most firms end up with pattern 1 for the bulk of fields and pattern 2 for one or two status changes that matter.
Every record that crosses needs a stable external ID stored on both sides. Match on that first; fall back to a deterministic key (NPI for providers, normalised email plus date of birth for patients, tax ID for accounts) only on first contact; never fuzzy-match in the sync. Log every fallback match for a person to review. A connector framework that solves OAuth, sync scheduling, deduplication and retries once, then reuses it for each new system, is what we built for Fundz, and it is why the third connector costs a fraction of the first.
If the PM system holds patient data, the integration moves PHI and your Salesforce org must be covered: a signed BAA with Salesforce, Shield or Health Cloud where field-level encryption and event monitoring are required, and a field map that moves only what Salesforce needs. Minimum necessary applies to integrations too. Log what was synced, when, and by which job, and keep credentials in a secrets manager, never in a flow or a spreadsheet.
APIs fail. Salesforce has daily API limits; PM vendors have rate limits and maintenance windows. A production integration needs:
- Idempotent writes, so a retried request never creates a second record
- Exponential backoff on 429 and 5xx responses, with a dead-letter queue for records that fail five times
- A reconciliation job that compares counts and checksums nightly and reports drift
- Alerts to a person when the sync falls behind by more than one interval
- A dashboard of last successful run, records moved, and failures
This is roughly a third of the build and the reason a Zapier-style connection works for a month and then quietly stops. For Samson Funding’s lending platform, third-party due-diligence calls were built for retries and traceability from the start, because the record of why a decision was made has to survive a vendor outage.
| Scope |
Timeline |
Range |
| One-way scheduled sync, up to 20 fields, one object |
4–6 weeks |
$15,000–$25,000 |
| Two objects, status events, document links, monitoring |
6–10 weeks |
$25,000–$45,000 |
| Client-facing dashboards on top (portal, live status) |
+4–8 weeks |
+$20,000–$40,000 |
Ranges reflect what we see across practice, credentialing and lending integrations. The PM vendor’s API quality moves the number more than anything else; some charge for API access or offer only nightly exports, which forces pattern 1 with file ingestion.
Can’t we do this with Zapier or Make?
For a single trigger with no retries and no PHI, yes. For a practice’s system of record, the missing pieces are deduplication, backoff, reconciliation and audit logging. Those are the integration.
Which practice management systems have you connected?
Credentialing and healthcare-practice systems through their REST APIs, plus Salesforce, HubSpot, QuickBooks and e-signature tools. If your vendor has an API, we can scope it in the first call; if it only exports files, that changes the pattern, not the feasibility.
How do we avoid Salesforce API limits?
Bulk API for the initial load, change-tracking queries for increments, and a sync interval tuned to your daily limit. A well-built sync of 10,000 records a day uses a small fraction of a standard org’s allowance.
What about the initial load of historical data?
It is its own step: export, clean, deduplicate, map, load with the Bulk API, then verify counts. Budget one to two weeks and expect it to surface duplicates that already exist in both systems.
Who maintains it when Salesforce or the vendor changes an API?
That is what the retainer covers. Integrations are not finished; they are owned.
Tell us which fields get re-typed and where the numbers differ. We’ll come back with a field-ownership table, the pattern we’d use, and a fixed scope for the first integration. Start a conversation.