How do you stop re-keying data between your CRM, ERP and other systems?

A new customer signs. Sales creates them in the CRM. Finance creates them again in the ERP, spelt slightly differently. Operations sets them up in the project or ticketing tool with a shorter name because the field was small. Three months later an invoice goes to the old address, a report shows two customers where there is one, and someone in finance spends a Friday afternoon working out which version is right.

Nobody designed it that way. Each system was bought by a different team for a good reason, and people typing filled the gaps between them. You can remove that typing without replacing any of the systems.

What re-keying costs, beyond the typing

The hours are the visible cost. Someone with real skills spends part of every day copying fields from one screen to another, and the time never shows up on a budget line because it's spread across six people in ten-minute pieces.

Errors cost more. Every copy is a chance to get something wrong, and the mistake surfaces somewhere else. A mistyped payment term in the ERP becomes a late payment. A missing order reference becomes an invoice nobody can reconcile. A customer who told one department about their move keeps getting post at the old address. Each takes an hour to untangle, once someone notices.

Disagreeing systems also cost you trust. When three systems disagree about how many active customers you have, every board pack starts with a caveat, and decisions get made on whichever number was quoted most recently.

Give every record one owner

The fix starts with a decision your team makes before any tool is involved. For each kind of record, name the system that owns it. The owner is where the record is created and changed. Every other system holds a copy and can't edit the fields the owner controls.

• Customers and contacts: usually the CRM, because that's where they first appear.
• Invoices and payments: the ERP or accounting system, always.
• Jobs, projects and tickets: the tool your delivery or service team works in.
• Products and prices: wherever the price list really lives. If that's a spreadsheet, this is a good moment to move it.

Ownership can be split by field. The CRM might own the customer's name and contacts while the ERP owns payment terms and credit limits. Every field still has exactly one owner, and everyone should know which it is.

Then agree one reference that travels with the record: a customer number, order number or job number, created once by the owner and written into every copy. Without it, connecting the systems means matching on names, and inconsistent names are how most companies got here.

How the connection works

Once the owners are decided, the automation is a set of carries. When a record is created or changed in its owner, the change is picked up, translated into the shape each other system expects, and written there. A deal marked won in the CRM becomes a customer in the ERP with the same name, address and reference. A status change on a job becomes a note on the account. An invoice posted in the ERP shows on the customer's CRM record, so sales can see it before they call.

Three rules keep this working once people rely on it.

• Log every carry: what changed, where, when, and what was written on the other side. When a value looks wrong, you can trace it back instead of guessing which system to blame.
• Send conflicts to a person. If a record was changed in two places before the carry ran, the system shouldn't pick a winner. Both versions go to the record's owner, side by side, with one click to choose.
• Close the side doors. If people can still create a customer directly in accounting, they will, and the copies drift apart again. The owner system becomes the only way in.

Most of this is plain integration: a field mapped to a field. AI earns its place at the edges, such as spotting that two differently spelt customers are the same company, or reading a free-text note to work out which job it belongs to. AI agents or workflow automation sets out how to tell which a step needs. Integration is cheaper to build and easier to test, so use it wherever it does the job.

Decide what to carry, and when

Carry only the fields the other systems need. Accounting needs the customer's legal name, billing address, payment terms, tax details and the shared reference. It doesn't need the deal stage or the sales notes. Carrying less means fewer conflicts and a log that's easier to read.

Most carries should run within minutes, so a deal won this morning is a customer in the ERP before anyone raises the first invoice. A few are fine overnight, such as a bulk status update across hundreds of jobs. Anything a system calculates from its own data, such as an outstanding balance, should be read from that system when it's needed, because a copied balance goes stale.

Documents are a case of their own. A signed contract belongs in one place, with links to it from the other systems. Three copies of a contract usually means three versions.

A worked example: customers between the CRM and the ERP

Take a hypothetical distributor with 300 staff. Sales creates new accounts in the CRM every week. Finance re-creates each one in the ERP, and the credit controller fixes addresses whenever an invoice bounces. The team agrees that the CRM owns the customer's name, address and contacts, the ERP owns payment terms and credit limits, and the CRM's account number goes into both.

Before switching anything on, they merge the duplicates and give every existing customer the shared reference. Then new accounts flow from the CRM to the ERP, and the finance lead reads the log each morning for the first few weeks. When the log has been quiet for a while, they add the ticketing tool, so service agents see the same customer details and the latest invoices.

Where to start

1. List every system the customer record lives in today, and who creates it in each.
2. Name the owner for each field and the shared reference. Expect a short, useful argument.
3. Clean the existing records once: merge duplicates, fix addresses, assign the reference. The connection keeps records in step from then on, but it won't repair the past.
4. Connect the owner to one other system, for new records only, while someone watches the log.
5. Add the next system, then the next kind of record.

The one-off clean-up is the step teams try to skip. It's a few days of someone's attention, and you only need it for the record you're connecting. Do you need to fix your data before you automate? covers how much clean-up is enough.

What to measure

• Hours of re-keying each week: ask each person who does it today, and ask again a month after go-live.
• Errors in your records each month: duplicate customers, invoices sent to the wrong address, orders missing a reference.
• Records in step: a monthly check that the customer count, and a sample of addresses and terms, agree across systems.

What to do this week

1. Ask each team who types customer details, into which system, and how often.
2. Pick the record that causes the most arguments.
3. Draft the owner for each of its fields and the reference that will travel with it.
4. Count the duplicates in your CRM and ERP so you know how big the clean-up is.

Connecting the systems you already run is a large part of our build work. We start with the record you pick, set up the carries and the log, and hand you a process your team can see working.

Get the next article when it's published.