Teams often describe an integration as a connection between two applications: a form sends a contact to the CRM, a completed job sends an invoice request, or a scheduling system updates a customer record. The technical connection is only one part of the operating design. The harder question is what should happen when information conflicts, arrives twice, changes out of order, or cannot be delivered.
A reliable integration begins with an operating agreement. Define which system owns each fact, what event is allowed to move it, who handles uncertainty, and how the team will know the complete business outcome occurred. Without that agreement, automation can make inconsistent data travel faster.
1. Define the authoritative record
“The CRM is our source of truth” is usually too broad. A CRM may own the contact relationship and sales stage while another platform owns the scheduled appointment, signed agreement, completed field work, payment, or accounting record. Authority should be defined at the record or field level.
Write down the owner, allowed writers, consumers, matching key, and correction path for each important fact. If two systems can independently overwrite the same field, the business does not yet have one source of truth.
2. Give every trigger an owner
An integration needs one unambiguous start event. “When the job is done” is not precise enough if a technician can upload a photo, add a note, change a status, complete a checklist, and close the work order at different times. Decide which event represents the business commitment and which system is authorized to emit it.
The trigger owner also owns the rule for corrections. If a completed record is reopened, does the integration send a revision, cancel the downstream action, or create a review task? A workflow that handles only the first successful path is a demonstration, not a dependable operating system.
3. Map meaning, not just fields
A field mapping spreadsheet should explain meaning as well as destination. Two fields named “status” may describe different things. One could mean the sales opportunity stage while another means whether a technician completed the approved work. Copying one into the other can produce a technically successful update with an operationally false result.
For every mapped value, document its definition, format, required state, valid choices, transformation, owner, and behavior when the value is missing or invalid. Preserve the original identifier and relevant timestamps so the team can trace where a record came from and in what order events occurred.
How do records match?
Use durable system identifiers where possible. Email addresses and phone numbers can change, be shared, or be entered inconsistently.
What does the value prove?
Separate submitted, reviewed, approved, completed, invoiced, and paid. Those states are not interchangeable.
Who may change it?
Make write permissions explicit instead of allowing the newest update to win automatically.
Can the change be traced?
Retain the source record, event, time, integration version, result, and correction path.
4. Design for retries and duplicates
Connections time out, workers retry actions, and platforms may deliver the same event more than once. A retry must not create a second opportunity, invoice, task, notification, or customer. The receiving workflow should recognize that it already processed the same logical event and return the existing result or safely ignore the duplicate.
Use a durable event or transaction identifier, define the matching window, and decide what information can be updated versus what must create a reviewed revision. This is sometimes called idempotent processing: repeating the same request should not create a different business result. Microsoft’s architecture guidance on idempotent consumers likewise emphasizes that retry behavior and duplicate delivery must be expected in distributed systems.
Do not rely on a person noticing duplicates after they reach the CRM. Duplicate prevention belongs in the workflow design, while a merge or correction process handles the cases that still escape.
5. Route exceptions without hiding them
A missing customer match, invalid address, closed accounting period, unavailable integration, or conflicting status should not disappear into a generic error log. Create an exception record that preserves the source evidence, identifies the affected business outcome, assigns a responsible person, sets a response target, and records the resolution.
Not every exception should block the entire workflow. For example, validated completed work may advance toward invoicing while a separate equipment recommendation waits for customer approval. The design should preserve safe progress without silently treating the unresolved item as complete.
6. Monitor the business promise
A green “automation ran” indicator only proves that a technical step executed. Monitor whether the complete outcome became true. If the promise is “completed field work reaches billing with usable documentation,” measure validated handoffs, exception rate, time to resolution, duplicate rate, manual re-entry, and the share of completed jobs that actually become invoice-ready.
Use operational thresholds that lead to action. Define who reviews failures, how often the queue is checked, what volume is abnormal, when the integration is paused, and how stakeholders are notified. Monitoring without a response procedure merely documents that the failure happened.
7. Build recovery before launch
The team needs a safe way to replay failed events, correct bad mappings, and reconcile records after an outage. Recovery should not require manually recreating every transaction or running an untested bulk action against production data.
Before launch, test unavailable systems, invalid credentials, permission changes, malformed payloads, rate limits, timeouts, duplicates, delayed events, out-of-order updates, and partial success. Document the pause control, manual fallback, replay process, verification query, escalation contacts, and rollback boundary.
Keep the integration version and configuration change history. When behavior changes, the team should be able to identify which rules applied to a particular record and restore the last responsible state.
8. Leave an operating record
A dependable integration is a maintained business capability, not a hidden set of connectors. The operating record should include the workflow diagram, source-of-truth matrix, field definitions, permissions, trigger and matching rules, exception paths, monitoring thresholds, recovery steps, change owner, and known limitations.
Review that record when a system, field, workflow, vendor, or responsible person changes. A connection can remain technically active while its assumptions become obsolete. Documentation makes those assumptions visible before they turn into silent data drift.
Start with one measurable handoff
Do not begin by connecting every available object. Choose one operational promise, trace one real transaction from beginning to end, and define the smallest responsible integration that makes it more reliable. Confirm the authoritative records, trigger, mapping, duplicate control, exception owner, monitoring, and recovery path before expanding.
A focused integration may use configuration, middleware, custom code, deterministic automation, or a bounded AI step. The tool is secondary to the operating design. The objective is not to move more data. It is to keep the right information connected to the right decision and next action.
The practical rule
Connect responsibility, not only software.
One reliable source of truth requires explicit authority, traceable events, owned exceptions, visible failures, and tested recovery.