System integration

System integration: ending manual retyping between your ERP and everything else

How to find the manual data transfer that costs the most, choose the right integration pattern, and connect systems that were never designed to talk.

Marco Pravato Published 4 min read

Every company runs on data transfers, and in most companies a surprising share of them are performed by a person retyping information from one screen into another - orders from the webshop into the ERP, delivery confirmations into a spreadsheet, invoices into accounting. System integration replaces those manual bridges with automatic ones. The business case is rarely subtle: count the hours spent retyping, add the cost of the errors, and compare with a one-off integration project - payback is typically months, not years. Here is how to find the right first integration and get it built properly.

Where does the retyping hide?

Ask each department one question - “what do you copy from one system into another, and how often?” - and a familiar list appears:

  • Sales orders from e-commerce or marketplaces, re-entered into the ERP.
  • Inventory and delivery status from the warehouse or 3PL, re-entered into customer-facing systems (or emailed on request, one customer at a time).
  • Invoices and payments between the ERP and the accounting platform.
  • Production data from machines and shop-floor sheets into planning spreadsheets - a big enough topic that manufacturers get their own guide.
  • Customer records maintained in parallel in the CRM, the ERP and the support tool, agreeing with each other only by luck.

Each of these costs three times: the hours (daily, forever), the errors (a mistyped quantity becomes a wrong shipment and an angry customer), and the latency (data arriving a day late makes every downstream decision a day late).

Which integration should you build first?

Rank candidates on four factors - the table settles most debates:

FactorWeight it high when.
VolumeThe transfer happens daily or many times daily
Hours consumedSomeone effectively has “retyping” as a part-time job
Error costA typo reaches customers, production or the books
Latency costDecisions wait on data that already exists elsewhere

The typical first winner is order flow (webshop → ERP) or invoice flow (ERP → accounting): high volume, measurable hours, painful errors. Resist starting with the technically interesting one; start with the one whose spreadsheet-owner will hug you.

How do systems that were never designed to talk get connected?

In descending order of elegance - all of them legitimate:

  1. APIs. Both systems expose documented interfaces; the integration calls them. Modern ERPs and SaaS platforms mostly live here.
  2. File exchange. One system exports, the other imports, on a schedule - old-fashioned and extremely reliable when built with reconciliation checks.
  3. Database-level access. Reading (rarely, and very carefully, writing) a legacy system’s database directly, when no interface exists.
  4. Interface automation. Software operating the legacy system’s own screens - the last resort that is still better than human retyping, because it never gets bored at 16:45.

The pattern that keeps this maintainable is the adapter layer: modern applications talk to a clean interface you own, and the adapter deals with the legacy system’s quirks behind it. When the old system is eventually modernized, you replace what’s behind the adapter - not every application that connected to it.

What separates a solid integration from a fragile one?

Anyone can connect two systems on a sunny day. The engineering is in the failure behaviour - insist on these as deliverables, not options:

  • Logging and alerting. When the nightly transfer fails, the right person knows in the morning, with enough detail to fix it - not a red light, and never silence.
  • Reconciliation. Periodic checks that both sides agree (order counts, invoice totals), because the worst integration failure is the silent partial one.
  • Idempotent retries. A transfer that runs twice must not create duplicate orders. This one sentence in the requirements saves an unpleasant week later.
  • Documentation. Interface specs and data mappings, so maintenance doesn’t depend on the vendor who built it - a point worth checking in any partner’s standard practice.

What does an integration project look like?

Small, usually. A typical first engagement: a one-week assessment mapping the flows and ranking candidates (you get the map and the ranking whatever you decide next), then a few weeks of build per integration, tested against reconciliation criteria before cut-over. It is a natural fixed-price shape once the assessment has defined the scope - and a natural pilot project for evaluating a partner, because it is real, bounded and off the critical path.

In short

  • Manual retyping costs hours + errors + latency, daily and forever; integration replaces it with a one-off project that typically pays back in months.
  • Find the first target by following the retyping and ranking by volume, hours, error cost, latency.
  • No API is no obstacle: files, database access and adapter layers connect systems that never planned to meet.
  • Judge quality by failure behaviour: alerting, reconciliation, safe retries, documentation - deliverables, not extras.
  • Start with an assessment week; it turns the integration backlog into a ranked, priced list.

Integration has been AD System Asia’s daily work since 2010 - ERPs, webshops, warehouses, legacy cores, in Thailand and in Europe. Tell us about two systems that should talk and don’t; we’ll propose the assessment.

A few more answers

Frequently asked questions

What does system integration mean in practice?

Making the systems you already own exchange data automatically - orders flowing from e-commerce into the ERP, deliveries back to the customer portal, invoices into accounting - instead of employees re-entering the same information by hand in two or three places.

How do I know which integration is worth building first?

Follow the retyping: list the places where staff copy data between systems, estimate hours per week and error impact for each, and rank. The winner is usually obvious - a daily, high-volume, error-prone transfer whose automation pays for itself within months.

Can old systems without an API be integrated?

Almost always. Legacy systems can be connected through their databases, file exchanges, or automation of their interfaces - wrapped in an adapter layer so modern applications talk to the adapter, not the fragile core. It is the most common integration case we see.

What should a delivered integration include besides the connection itself?

Logging, error handling and alerting - so a failed transfer notifies the right person with enough detail to act - plus documentation of the interface and data mappings so your team, or any future vendor, can maintain it without archaeology.

Is middleware or point-to-point integration better?

For one or two connections, point-to-point is simpler and cheaper. When several systems exchange several flows, a middleware or integration layer stops the connection count exploding and gives you one place to monitor. Start point-to-point, refactor to a layer when the third or fourth flow arrives.