The connector is the easy part. Agreeing who owns the field is the project.
Most integration failures are not technical. Two systems were connected without anyone deciding
which one is authoritative, what happens when they disagree, or who finds out when the sync
stops. Twopir Consulting designs the data contract first, then builds to it — so the automation
removes the re-keying instead of adding a reconciliation task. Ownership, direction, frequency, conflict rules and failure behaviour, agreed up front.
Contract RuleExactly one system is authoritative per field
Definition
What do Nintex integration services cover?
Nintex integration services connect Nintex processes to the systems that own your data, so a
workflow can read what it needs, act on it, and write the result back to the system of record
rather than to a person. Nintex provides a large connector library and a framework for building
custom connectors. The consulting work is deciding what should be connected, which system is
authoritative for each field, how conflicts resolve, and how you find out when a sync fails.
This page is the programme. The engineering layer underneath it — building a
custom connector from an OpenAPI definition, authentication, pagination, rate limits and retry
design — is covered separately on Nintex API & integration services.
If your question is "which systems should talk to each other and who owns the data", you are on
the right page. Both sit inside the wider Nintex consulting practice,
and where an integration is being built as part of a first deployment it is scoped as a
workstream of the implementation rather than as a separate project.
The Landscape
What we connect, and what actually moves
A list of logos tells you nothing. For each of these, what matters is which direction the data
moves, which team consumes it, and what stops happening manually once it does.
Nintex + Salesforce
Salesforce stays authoritative for the customer, the opportunity and the quote. Nintex reads that record to drive approval routing and document generation, and writes back the approval outcome, the generated document and its signature status — so the rep sees the executed contract on the opportunity instead of in an inbox.
Direction: read customer and deal data, write process outcome
Consumed by: sales, revenue operations, finance
Stops: re-keying deal terms into a document by hand
SharePoint remains the document store and the retention boundary. Nintex starts from a document or list change, surfaces approvals as tasks in Outlook and Teams where people already are, and files the completed output back with metadata set by the process rather than typed by whoever saved it.
Direction: trigger from content, write files and metadata back
Consumed by: every function that files documents
Stops: hand-applied metadata and untracked email approvals
Nintex + ERP and finance
The ERP owns the transaction. Nintex owns the approval that precedes it — validating against budget and vendor status at entry, routing by the authority matrix, then posting the approved request as a transaction so finance reconciles against a record rather than an email thread.
Direction: read budget and vendor, write the approved transaction
Consumed by: finance, procurement, audit
Stops: approvals evidenced only in mailboxes
Nintex + ServiceNow and ITSM
The ticket stays the requester's single view. A raised request triggers the fulfilment process in Nintex — provisioning, asset assignment, approvals — and each completed step updates the ticket with real status, so nobody has to check two systems to find out where their request is.
Direction: ticket triggers process, process updates ticket
Consumed by: the requester, service desk, IT operations
Stops: status chased across two tools
Nintex + HR and identity systems
The HR system owns the employment record; the directory owns access. A joiner or leaver event starts the provisioning or revocation process, and the completion of each task writes back so an audit can answer when access was granted and when it was removed.
Direction: HR event in, provisioning evidence out
Consumed by: HR, IT, security, audit
Stops: leavers whose access quietly outlives them
Nintex + eSignature platforms
The signature platform owns the executed document and its legal audit trail. The process sends the generated document, then waits on the completion event rather than on a person noticing an email — and the signed file plus its status return to the source record automatically.
Direction: send for signature, receive completion event
Consumed by: sales, legal, finance
Stops: deals waiting on someone checking a mailbox
Nintex + in-house and industry systems
Anything with a REST API can become a first-class connector through the Nintex Xtensions framework, defined in OpenAPI. That is how a core banking platform, a practice management system or an internal service joins the estate without buying a middleware tier to sit in front of it.
Direction: defined per operation, not assumed
Consumed by: whichever process needs it
Stops: a bot clicking through a screen that has an API
Reporting reads and never writes. Process and execution data is exported to the platform leadership already uses, so automation performance appears beside the operational numbers it is meant to be moving rather than in a separate tool nobody opens.
Direction: read-only, out of the process
Consumed by: operations leadership, finance
Stops: automation value being argued rather than shown
Six questions we answer before anything is connected
Each of these takes a conversation and saves a quarter. Skipping them is how an integration
becomes a permanent source of data disputes nobody can adjudicate.
The data contract, decision by decision
Decision
The question
What happens if nobody decides
Field ownership
For each field, which system is authoritative — and therefore which one may overwrite the other?
Both systems write. The last one to run wins, the value flips back and forth, and nobody trusts either.
Direction
Is this one-way, or two-way? If two-way, what is the conflict rule when both sides changed?
Two-way by default, no conflict rule, and a support ticket every time a field mysteriously reverts.
Trigger and frequency
Event-driven, scheduled, or on demand — and how stale is the consuming side allowed to be?
Everything is real-time "to be safe", the API limits are hit at month-end, and the sync stops when it matters most.
Identity and matching
What key links a record in one system to its counterpart in the other, and what happens when there is no match?
Matching on name or email, duplicate records within weeks, and a manual merge job that never ends.
Failure behaviour
What happens on a transient error, on a permanent one, and who is told?
The sync fails quietly. The business finds out. Nobody can say how long it had been broken.
Reconciliation
How do we detect that the two sides have diverged, even when nothing reported an error?
Divergence is discovered during an audit or a month-end close, at the worst possible moment.
We document these per integration and hand them over as part of the architecture. It is a short
document, and it is the one your team will reach for every time something looks wrong.
Patterns
Real-time, scheduled, event-driven or bulk?
The default answer is usually "real-time", and it is usually wrong. Choose the pattern from how
fresh the data genuinely needs to be and what the source system can sustain.
Four integration patterns compared
Pattern
Use it when
Cost to watch
Typical use
Request–reply
The process needs a value at the moment it makes a decision, and cannot proceed without it.
The process is now coupled to the other system's availability and latency.
Credit check, stock level, entitlement lookup at the point of approval.
Event-driven
The source system can publish a change, and you want the process to start from it rather than poll for it.
Events can be missed or arrive out of order. You need idempotency and a catch-up path.
Record created, signature completed, ticket raised.
Scheduled batch
The consuming side tolerates minutes or hours of staleness, and volume is predictable.
Nobody notices a failure until the next window. Needs its own alerting.
A large one-off or periodic movement of records, typically during migration or onboarding.
Rate limits and processing windows dominate. Needs restartability from a known point.
Initial migration, annual data refresh, acquisition onboarding.
Most estates use three of these. The design question is per integration, not per platform — and
"real-time everywhere" is the answer that most reliably produces throttling at month-end.
How We Work
From landscape map to a running, monitored integration
Step 01
Landscape & Ownership Map
Which systems hold what, which are authoritative, where the same value already exists in three places, and which of those copies anyone actually trusts.
Step 02
Contract Design
The six decisions above, agreed per integration with the system owners in the room and written down — including the conflict rule nobody wants to discuss.
Step 03
Build & Authenticate
Connectors configured or custom-built, service identities and scoped credentials established, field mapping implemented, and retry and alerting wired in from the start.
Step 04
Test the Failures
Disconnect the endpoint, exceed the rate limit, send an unmatched record, change a field on both sides at once. If the design survives these, production is unlikely to surprise it.
Step 05
Monitor & Reconcile
A scheduled reconciliation that compares both sides, alerting that reaches a named owner, and documentation your team can act on without calling us at two in the morning.
Common Questions
Integration questions worth settling early
Often not. Nintex's connector library plus custom connectors built on its extensibility framework covers a great deal of process-driven integration, and adding a middleware tier for four integrations is expense without benefit. A dedicated integration platform earns its place when you have high-volume, system-to-system data movement with no human step, complex transformation and mapping across many endpoints, or an existing enterprise integration standard you are required to use. We will tell you which case you are in rather than defaulting to the more expensive one.
It writes back, and for most processes it must — otherwise the automation ends with someone copying an outcome into the CRM by hand, which is the step you were trying to remove. The design question is what it is allowed to write. We keep Salesforce authoritative for customer and deal data, and let the process write only what the process owns: approval outcome, generated document, signature status, stage progression. That boundary is what stops an automation from overwriting a value a human deliberately changed.
In order of preference: find the API that exists but was not documented internally, use a supported file or database interface, or — last — automate the interface a person would use with a bot. Robotic automation is legitimate here and sometimes the only option, but it is materially more fragile than a call and breaks on cosmetic interface changes nobody announced. We design those steps so the process expects them to fail, and we replace them the moment a real interface becomes available.
Whatever the conflict rule says, which is why the rule is agreed before the build. The common options are that the authoritative system always wins, that the most recent change wins, or that a conflict is not resolved automatically at all but raised to a person as an exception. The third is the right answer more often than teams expect — for fields where a silent overwrite would be worse than a short delay. What never works is having no rule, because then the answer is whichever job happened to run last.
Two mechanisms, because one is not enough. Error alerting catches failures that report themselves and routes them to a named owner rather than a log. Scheduled reconciliation catches the failures that do not report themselves — the sync that silently stopped, the records that were skipped, the field that stopped being populated — by comparing both sides and flagging differences. The second is the one most estates lack, and it is the reason divergence usually surfaces during a month-end close.
Work with them, unless there is a specific reason not to. We document what exists, identify which ones have an implicit contract nobody wrote down, and add monitoring and reconciliation where they are missing — which is usually the cheapest meaningful improvement available. Replacement is worth it when an integration fails regularly, has no owner, duplicates another, or blocks something you are about to build. Rebuilding working integrations to a house standard is rarely a good use of the budget.
Next Step
Bring us the two systems that keep disagreeing, and we will find out why
A short landscape session usually surfaces the answer quickly: an undocumented two-way sync, a
missing conflict rule, or a match key that was never going to be unique.