Salesforce Field Service Integration

A work order nobody can invoice is just a note.

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.

Integration Architecture
CONNECTED SYSTEMS ERP Items · Stock · Costs · Invoices Field Service Work Orders · Appointments · Assets IoT & Telematics Warehouse / WMS Billing & Contracts TWOPIR INTEGRATION LAYER Data Contract Owner per field Direction · Keys Movement Events · Batch Retry · Errors Reconciliation Drift detection Audit trail ONE OWNER PER FIELD · NEVER TWO 2πr CONNECTED OUTCOMES Parts Known Stock checked before the van leaves Faster Invoicing Billable lines reach finance on completion One Asset Truth Service history that every system agrees on CONTRACT · MOVE · RECONCILE · AUDIT
Where Integrations Fail

Six failures that only show up in production

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.

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.

Nobody owns the failure queue

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.

Everything is real-time because nobody asked

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.

The asset in the ERP is not the asset in Field Service

No shared key between serial numbers, equipment records and installed base means service history splits across systems and preventive maintenance can never be trusted.

Billable work reaches finance as a PDF

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.

IoT alerts create noise instead of work

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.

The Data Flows

What moves, which way, and who consumes it

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.

Salesforce Field Service integrations showing direction of data flow, what moves, and which team consumes it
SystemsDirection & what movesWho depends on it
Field Service ↔ ERPERP → 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 / WMSFS → 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 ↔ BillingFS → 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 ServiceOne-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 ContractsContracts → 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 → NotificationsOut: 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 ServiceOne-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.

How We Connect It

Middleware, or a direct API build?

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.

Point-to-Point

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.

  • Best when there are one or two integrations total
  • Lowest running cost, highest marginal cost per new link
  • You own the error handling and the retry logic
  • Fine for a stable, well-documented target system
  • Becomes unmanageable past three or four connections

Integration Platform

MuleSoft, Celigo, Boomi or similar sitting between the systems. Monitoring, retry and error handling come with the platform rather than being built per connection.

  • Best from roughly three integrations upward
  • Failure queues and replay are built in, not bespoke
  • Prebuilt connectors shorten common ERP work
  • Licence cost, and a platform your team must learn
  • Usually the right call for a real field service stack

Event-Driven

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.

  • Best for genuinely time-critical flows
  • Decouples systems — no polling, no fixed windows
  • Needs deliberate replay and ordering design
  • Usually combined with batch for bulk reference data
  • Not a default — most reference data should be batched
How We Deliver

Contract first, code second

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.

Step 01

System & Ownership Map

Every system in scope, every field that crosses a boundary, and one named owner per field. Disagreements surface here rather than in production reconciliation.

Step 02

Data Contract

Direction, trigger, frequency, shared keys, transformation rules and what a failure means for each flow. This is the document the build is tested against.

Step 03

Build & Instrument

The integration itself, with monitoring, a visible failure queue and replay designed in from the start rather than added after the first incident.

Step 04

Parallel Run

Both systems running together against real transactions, with a reconciliation report. Nothing cuts over until the numbers agree for a full cycle.

Step 05

Handover & Drift Watch

Runbooks for the people who will own it, plus ongoing reconciliation so silent drift is caught in days rather than at quarter end.

Integration Outcomes

What connected systems change in the field

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.

Case Study

HVAC Services Company — Multi-Region

Integrating inventory with Field Service so parts were known before dispatch.

25% Higher first-time fix rate
20% More jobs completed per day
40% Improvement in customer satisfaction

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.

Deployment Pattern

Integrating Around Existing Systems

A published example of integration-led field service delivery.

  • Furniture manufacturer and dealer — the company struggled with complex logistics and inefficient resource allocation, and customer details were being entered manually outside the CRM.
  • What integration changed — connecting Field Service with the systems already in place gave technicians access to schedules, inventory and customer data on the job, wherever they were working.
  • The operational result — less time spent on logistics coordination and more on the service itself, using fully automated, paperless tools rather than re-keyed records.
  • Why it generalises — the pattern is the same in every sector: the field team is only as good as the data that reaches the van.
See the Full Service Range
Related Capabilities

What integration unlocks next

Asset & Maintenance

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.

Customization

Where an integration needs logic inside Salesforce — custom objects, Apex on work orders, validation the standard model does not express.

Automation

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.

Implementation

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.

Common Questions

Questions architects ask us first

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.

Next Step

Bring us your system list, and we will draw the boundaries

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