Each system works on its own. The trouble starts at the seams: data gets moved by hand and nobody knows which copy is right. Integration removes the seams.
One event on the site, and the data reaches every system in the right format, with validation and a retry if something fails.
sync.vmtech.rs
Event: order paid
LIVE
all systems in sync
The event is captured
webhook received
Data is mapped to a format
fields mapped
Sent to the CRM
deal #2184
Sent to the warehouse
stock updated
The response is checked
retry in 30 s
Written to the log
all systems in sync
DATA EXCHANGE
01The event is capturedThe site sends a webhook: what happened, to which order and exactly when
02Data is mapped to a formatFields are mapped: the site's SKU to the warehouse code, currency, units, tax rate
03Sent to the CRMA deal is created with an owner, a source and history — or an existing one is updated
04Sent to the warehouseStock is written off and the documents are created in the accounting system
05The response is checkedIf a system answers with an error the step retries instead of failing silently
06Written to the logYou can see what went out, what came back and how long each exchange took
A FAMILIAR PICTURE
What happens when systems do not talk
Manual exchange
The same order is entered twice: on the site and in the accounting software
A daily spreadsheet export means stock is wrong for half the day
An error surfaces a week later, when the numbers are reconciled
Nobody knows which system holds the correct price
When an employee leaves the process stops: it lived in their head
Exchange in place
Data is entered once and arrives where it is needed, in the right shape
Stock and prices update on events, not once a day
A failure is visible at once: the owner gets a notification with the error
Every field has a defined source of truth — there is nothing to argue about
The process is documented and runs regardless of who is in the office today
SCOPE OF WORK
What an integration project includes
Audit of systems and data
Which systems take part, what fields they hold and what counts as the source of truth for each value.
The exchange design
What goes where, at which moment, how often, and what happens when data conflicts.
Field mapping
SKUs, units, currencies, tax rates and statuses are reduced to one shared vocabulary.
Building the connectors
REST and SOAP APIs, webhooks, FTP file exchange, direct database access — whatever the system offers.
Error handling
Retries, a queue of undelivered items, notifications to the owner and a manual re-run.
Exchange log
A history of every request and response, so disputes are settled on facts rather than memory.
A test environment
We test the exchange against a data copy, so live databases stay clean during setup.
Documentation and handover
The exchange diagram, a field reference and instructions for when an outside system changes.
TECHNOLOGY LANDSCAPE
What we connect with
REST / JSONThe main way to exchange with modern services and cloud CRMsWebhooksEvents arrive immediately, without polling a system every few minutesSOAP / XMLThe format still used by many accounting and banking systemsFile exchangeCSV and XML over FTP or SFTP where no API exists at allJob queuesThe exchange never blocks the site and survives an outside system being downExchange monitoringAn alert if the flow stops or the error rate climbs
Access to outside systems and their licences stay with you. We work within what their interfaces allow, and say up front when a system simply cannot do what is needed.
QUESTIONS
What people usually ask before we start
Our system has no API. What then?
There are usually more options than it seems. Many programs can export and import files on a schedule — enough for stock and prices. Sometimes read access to the database exists. If neither is available, we say so before the work starts, not after.
How often will data update?
It depends on what the system allows and what the business needs. Orders and payments usually go out immediately on an event. Stock and prices go by event if webhooks exist, or on a schedule if polling is required. We pick a frequency that stays inside rate limits.
What if an outside system changes its API?
It happens, so the exchange is built to fail loudly. Monitoring catches the rise in errors, the log shows which request stopped working and the queue holds the data until it is fixed. We repair the connector and replay what accumulated — no orders are lost.
Can two systems that describe the same customer differently be connected?
Yes, but a matching rule has to be agreed first: by phone, by email, by tax number. We look at the real duplicates in your data, propose the rule with the fewest errors and route ambiguous cases to a separate list for a human to check.
Who owns the integration code?
You do. The code, the exchange design and the documentation are handed over with the project, and server access stays yours. We do not build integrations as a black box that cannot be maintained without us.