Skip to Content

Integrations with clear data and responsibility

We connect systems where manual transfer gets in the way. We define the authoritative data source, transfer rules and error response. The goal is not just to connect two APIs but to preserve the meaning of a customer, order or document throughout the journey.

Discuss data exchange

What your company gets

Data reaches the right place.

Every object has a known source and recipient.

Less repeated manual work.

The exchange removes only duplication that actually needs removing.

Visible errors.

The team learns about missed events and how to continue safely.

Verifiable responsibility.

One business action has a clear result in both systems.

Check the change in both systems

Data goes out; confirmation comes back

Source system

Owns the agreed fact and event identifier.

Permitted transfer

Agreed fields, direction and access.

Receiving system

Verify the actual record change.

Receiver → source: acknowledgement

Return the confirmed result with the source event identifier.

Unconfirmed result: check before retry

A repeated message must not create another order, refund or email.

Unresolved error → responsible person

Keep the state visible and agree recovery.

Example: an accepted order changes the receiving system. If a message is retried, it must not become a second order, refund or email; unresolved errors go to the agreed responsible person.

Agreed scope and delivery checks

What we work on

  • Define which data moves, in which direction and which system owns it.
  • Prepare API connections, mappings, schedules and access boundaries.
  • Handle failures, retries and duplicate records in the agreed scenarios.

What you take away

A verified connection with documented data rules, error handling and responsibility for ongoing operation.

How we work

Understand

Review the systems, available interfaces and data quality.

Agree

Agree the source of truth, mappings, access and allowed actions.

Build

Connect a focused flow and test normal and failure scenarios.

Verify

Verify records and hand over monitoring and recovery instructions.

Our approach →

When the connection works but the process does not

An order is sent twice. A price changes on the website but not in the proposal.

A shared email merges different people. A provider accepts a payment but the response is lost. These situations cannot be fixed by a single promise of real-time synchronisation.

We start with rules: which system determines the value, exactly what is transferred, when a change is confirmed and who handles exceptions.

What the work includes

Sources and object mapping

We establish where products, contacts, orders and financial documents are managed.

We agree identifiers, required fields and relationships. We do not merge different entities merely because their names are similar.

A suitable transfer method

We check available interfaces, licences, permissions, limits and data.

We select an API, event, batch exchange or controlled import for the actual need. A manual start with confirmation can be more sensible than a complex unverified integration.

States, retries and exceptions

We distinguish prepared, sent, accepted, rejected and unknown outcomes.

A retry must account for an action already performed. When a response is lost, we first reconcile state rather than automatically create a second order or payment.

Monitoring and reconciliation

We prepare useful logs without unnecessary personal data, delay alerts and a way to reconcile results.

The team can see what needs attention and how to continue. A technical response code does not replace checking the business object.

Supplier exchange: trace each confirmed fact

Illustrative record · not a completed client project
Source
Catalogue ↔ ERP: agree where product, price and stock are confirmed; rules may differ
Transfer
Carry the event identifier and distinguish independent objects
Confirmation
An order does not promise a reservation before it is confirmed
Unknown outcome
Reconcile the responsible system before a safe retry; prevent a second order
Exceptions
Retain partial delivery and changes to the configuration

Two examples

An academy connects sales and learning.

Customer, payer and learner are transferred as different roles. A confirmed payment creates only the agreed basis for access; allocation of corporate places and cancellation of participation are checked separately.

How we test an integration

We agree examples and exceptions before implementation.

We check normal transfer, retry, service unavailability, invalid data and a lost response. Correction of an already transferred record and stopping the exchange are considered separately. Real external effects occur only in an authorised test or working scenario.

After launch pNet helps support the connection: track interface changes, investigate discrepancies and refine rules.

System and data owners remain defined; integration does not remove their responsibility.

What your team receives

A map of objects and sources, agreed transfer rules, a way to check results and instructions for exceptions.

It is clear which data moves, what stays in place and where a person is needed.

EventAn enquiry arrives
What counts as a resultThe correct CRM record is created and an owner assigned
What to do on failureReconcile the original request before resending
EventAn order is confirmed
What counts as a resultThe accounting system receives the correct identifier and contents
What to do on failureCheck the main record in the agreed system; prevent a second order
EventA status changes
What counts as a resultThe recipient receives an allowed change
What to do on failureRecord the conflict and refer it to a person

For a supplier, a catalogue enquiry can become a proposal, then an order and shipment.

At an academy, registration and payment do not yet mean a place has been assigned to a specific participant. pNet selects one authoritative record, documents field mapping and transfers only events that are actually needed.

Failures matter especially: an external service may have performed an action while its response was lost.

A retry must not become a second order, refund or email. We provide an operation identifier, retained state and a way to determine the result without a blind retry. API, plan, permissions, provider limits and the right to change records are checked before implementation.

CRM handles business stages; process automation can connect agreed steps; and monitoring helps reveal and investigate errors.

Without an API, an honest manual stage is better than a fictitious seamless integration.

All pNet business systems.

Frequently asked questions

What do we agree before work starts?

Availability depends on external APIs, permissions and provider limits. Historical migration and changes to connected systems are separate scope.

What should I share to get started?

Describe your systems, the problem and any known constraints. You do not need a complete technical specification. Please leave passwords, keys and customer data out of your message.

Can you connect any application?

That depends on its available interface, permissions, licence and provider terms. We check compatibility before promising a ready connector.

Will exchange be instant?

Acceptable latency is determined by the process. Interface capabilities and system limits are checked separately; real time is not assumed by default.

Is CSV enough for migration?

Sometimes, for a limited set. Relationships, history, attachments, permissions and identifiers may need another method. A file format does not prove a complete migration.

Can every error be retried automatically?

No. With an unknown outcome, retrying can create a second effect. State checks and suitable reprocessing rules are needed.

Let's connect one important handoff

Tell us where information comes from and goes, who corrects it and what happens on failure. We will choose a useful scope and verifiable rules.

Discuss data exchange