Nintex Integration Services

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.

The Data Contract
SYSTEMS OF RECORD CRM Customer, contact Opportunity, quote Owns: the relationship ERP Order, invoice Vendor, budget Owns: the money Content Store Files, metadata Retention policy Owns: the document THE DATA CONTRACT Field Ownership One authoritative system per field Direction One-way, or two-way with a conflict rule Trigger & Frequency Event, schedule or on demand Failure Behaviour Retry, alert, who is paged CONSUMERS Nintex Process Reads to decide Writes the outcome Holds process state Service / ITSM Raises the request Shows real status Never re-keyed Reporting Reads only Never writes back One version of truth 2πr RECONCILIATION Compare Both sides, on a schedule Flag Differences, not silence Assign To a named owner
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
Nintex for Salesforce document generation

Nintex + Microsoft 365 and SharePoint

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
How we build custom connectors

Nintex + BI and reporting

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
Nintex analytics & reporting
The Data Contract

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
DecisionThe questionWhat happens if nobody decides
Field ownershipFor 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.
DirectionIs 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 frequencyEvent-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 matchingWhat 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 behaviourWhat 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.
ReconciliationHow 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
PatternUse it whenCost to watchTypical use
Request–replyThe 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-drivenThe 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 batchThe consuming side tolerates minutes or hours of staleness, and volume is predictable.Nobody notices a failure until the next window. Needs its own alerting.Overnight reference data, daily finance extracts, periodic reconciliation.
Bulk loadA 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.

Integrations with an owner per field and a reconciliation that runs