Two systems both think they own stock levels
Field Service deducts a part at debrief, the ERP deducts it again at goods issue, and inventory drifts until someone does a manual count. One owner per field, always.
Field Service holds the job. Your ERP holds the item master and the money. Inventory holds the part. Until those connect, technicians guess at stock and finance invoices weeks late. Twopir designs and builds the integrations — naming what moves, in which direction, and who consumes it. Data flow design, not a connector install.
Field service integrations rarely fail at connection time. They fail months later, quietly, when two systems disagree about the same number. Design decisions, not connectivity problems.
Field Service deducts a part at debrief, the ERP deducts it again at goods issue, and inventory drifts until someone does a manual count. One owner per field, always.
Records that fail to sync go somewhere nobody watches. By the time finance notices missing invoices, there are four thousand of them and no way to replay in order.
Item masters do not change every second. Syncing a full catalogue in real time burns API limits that the flows which genuinely need to be immediate — like an emergency work order — then cannot use.
No shared key between serial numbers, equipment records and installed base means service history splits across systems and preventive maintenance can never be trusted.
Parts consumed and labour hours are captured in the field, then re-keyed into the billing system from a service report. The delay and the error rate are both entirely avoidable.
Every threshold event becomes a case, so dispatchers ignore them all. Without filtering and de-duplication, connected equipment makes the board worse rather than better.
An integration diagram with logos on it tells you nothing. This is the same information stated usefully: the direction of each flow, what actually travels, and which team depends on it.
| Systems | Direction & what moves | Who depends on it |
|---|---|---|
| Field Service ↔ ERP | ERP → FS: item master, pricing, stock on hand. FS → ERP: parts consumed, labour hours, job cost at debrief. | Finance costs the job; dispatch sees what is genuinely available. |
| Field Service ↔ Inventory / WMS | FS → WMS: product requests and transfers, van stock deductions. WMS → FS: confirmed quantities, replenishment status, location stock. | Technicians know the part is on the van; the warehouse replenishes automatically. |
| Field Service ↔ Billing | FS → Billing: billable lines from the completed work order. Billing → FS: invoice number, payment status, disputes. | Finance invoices in the same week; service settles disputes against the job record. |
| IoT / Telematics → Field Service | One-way in: filtered threshold and fault events, de-duplicated, raised against a specific asset. | Dispatch schedules before the customer calls; maintenance sees real failure patterns. |
| Field Service ↔ Service Contracts | Contracts → FS: entitlement terms, SLA clocks, warranty coverage. FS → Contracts: consumption against the agreement. | Technicians know before quoting whether the visit is covered or chargeable. |
| Field Service → Notifications | Out: appointment confirmed, en route, completed. Back: delivery status and customer replies onto the appointment. | Customers stop phoning for an ETA; dispatch sees failed contact before the truck rolls. |
| Legacy FSM → Field Service | One-way migration: assets, service history, contracts and open work, with relationships preserved and a parallel-run reconciliation. | Everyone — this is the cutover, and it is only safe when the reconciliation balances. |
We write this table for your stack before any build starts. It is the artefact that stops two systems quietly claiming ownership of the same field.
There is no universally right answer, and any partner who gives you one before seeing your stack is selling something. These are the three shapes and when each is genuinely the better call.
A direct build between Field Service and one system, using the platform APIs on both sides. Fewer moving parts and no licence, but every new connection is new code.
MuleSoft, Celigo, Boomi or similar sitting between the systems. Monitoring, retry and error handling come with the platform rather than being built per connection.
Platform Events and change data capture rather than scheduled batches. The right shape when something must react immediately — an IoT fault, an emergency work order.
Most integration rework comes from starting to build before anyone agreed which system owns which field. We settle that on paper first — it is the cheapest hour in the project.
Every system in scope, every field that crosses a boundary, and one named owner per field. Disagreements surface here rather than in production reconciliation.
Direction, trigger, frequency, shared keys, transformation rules and what a failure means for each flow. This is the document the build is tested against.
The integration itself, with monitoring, a visible failure queue and replay designed in from the start rather than added after the first incident.
Both systems running together against real transactions, with a reconciliation report. Nothing cuts over until the numbers agree for a full cycle.
Runbooks for the people who will own it, plus ongoing reconciliation so silent drift is caught in days rather than at quarter end.
The figures below come from one documented engagement with an HVAC services company running more than 100 field technicians across multiple regions. They describe that client's results — not an industry benchmark and not a Twopir average.
Integrating inventory with Field Service so parts were known before dispatch.
Technicians were arriving on site without complete knowledge of the equipment or parts the job required, which forced follow-up visits. Integrating Field Service with the client's inventory system to track parts usage and confirm technicians had what each job needed was a direct contributor to the 25% improvement in first-time fix rate — the metric that most directly reflects whether an integration is doing its job.
A published example of integration-led field service delivery.
Once assets share a key across systems, preventive maintenance becomes possible — and IoT events can raise work against the specific piece of equipment that reported them.
Where an integration needs logic inside Salesforce — custom objects, Apex on work orders, validation the standard model does not express.
Integrated data is what makes automation safe. An IoT event can only create the right work order if the asset, contract and entitlement are already connected.
If you are deploying Field Service for the first time, integrations belong early in the plan — they are the usual reason a go-live date slips.
The ERP should own the item master, costing and warehouse stock, because that is where purchasing and finance already live. Field Service should own van stock and consumption at the point of work, because that is where the movement actually happens. The failure mode is both systems believing they own the same number — Field Service deducting a part at debrief while the ERP deducts it again at goods issue. The integration's job is to make each movement travel exactly once, in one direction, with a shared key.
It depends on how many integrations you will genuinely end up with, not on how many you are building today. For one or two stable connections, a direct API build is often cheaper to own and has fewer moving parts. From about three upward, an integration platform such as MuleSoft, Celigo or Boomi usually wins, because monitoring, retry, failure queues and replay come with the platform instead of being rebuilt per connection. The honest test is whether you want to own error handling yourself — that, more than connector availability, is what you are buying.
Filtering and de-duplication before anything reaches Salesforce. Connected equipment emits far more events than are worth a truck roll, so the design question is which threshold combinations genuinely indicate a fault, how long a condition must persist before it counts, and whether an open work order already exists for that asset. Done properly, a threshold breach creates a work order against the specific asset before the customer notices. Done without filtering, dispatchers learn to ignore the alerts within a fortnight and the investment is wasted.
Yes. The technical work is moving assets, service history, contracts and open work with their relationships intact; the hard part is deciding how much history is worth bringing. Full history makes reporting continuous but carries every data quality problem the old system had. We usually migrate assets and contracts completely, migrate service history for a defined period, and archive the rest somewhere retrievable. Nothing cuts over until a parallel run reconciles — if the numbers do not agree in both systems for a full cycle, the migration is not finished.
That is a design question, and it is the one most integration projects answer too late. Every flow needs a defined failure behaviour: whether the record retries automatically and how many times, whether it lands in a queue a named person actually monitors, whether downstream processing should halt or continue, and whether replay must preserve ordering. We build the failure queue and the replay mechanism as part of the integration rather than after the first incident, because retrofitting ordering guarantees into a live integration is considerably harder than designing them in.
No, and assuming it does is expensive. Item masters, price books and customer records change slowly and belong in scheduled batches. Stock levels usually need to be near-real-time only for the locations dispatch actually checks before assigning work. Genuinely immediate flows are a short list: emergency work order creation, IoT fault events, and appointment status updates that customers are watching. Making everything real-time consumes API capacity that the flows which truly need immediacy then cannot get, so the design starts by asking what breaks if a given flow is twenty minutes late.
The first deliverable is an ownership map: every field that crosses a system boundary, and exactly one owner for each. Most integration rework disappears once that document exists.
Speak with a team that designs the data contract before writing the connector