Making your software talk to each other

Most small businesses do not run one system. They run a stack: a customer relationship manager, an accounting package, an email tool, a scheduling app, a form on the website, maybe a spreadsheet or two holding the whole thing together. Each one is fine on its own. The pain shows up in the gaps between them — where a person copies a new customer from the web form into the accounting system, then again into the mailing list, then updates a spreadsheet so someone else knows it happened.

That copying is where errors, delays, and single-person dependencies live. Connecting your tools so they pass data automatically is called integration, and for a lot of these gaps you can set it up yourself in an afternoon.

What “integration” actually means

An integration is a rule that says: when something happens in one system, do something in another. A new order in your store creates a customer record in accounting. A signed contract in your document tool starts an onboarding checklist. A paid invoice sends a thank-you email and updates a dashboard.

You do not need to understand how it works under the hood to use it well. You need to know which of three approaches fits the job:

• Manual export and import. You download a file from one system and upload it to another. No tools, no cost, full control. Fine for occasional, low-volume, one-direction moves.
• Low-code automation. A tool like Zapier, Make, or Microsoft Power Automate sits between your apps and moves data on triggers you define, through a visual editor. No programming. This covers the large majority of small-business needs.
• Application programming interface (API) integration. Two systems talk directly through the “doors” software vendors build for exactly this purpose. More reliable and faster at volume, but it usually needs a developer to build and maintain.

Most businesses use all three at once — a manual export for the quarterly thing, low-code for the daily flows, and a purpose-built API integration for the one connection that has to be rock-solid.

Low-code tools versus a real API integration

The honest way to choose is by asking how much the flow matters and how often it runs.

Question	Lean low-code	Lean custom API
How many records per day?	Dozens to a few hundred	Thousands, or spiky bursts
How bad is a 15-minute delay?	Tolerable	Not acceptable
How complex is the logic?	A handful of if-this-then-that steps	Branching, lookups, error handling
Who maintains it?	You or an office manager	A developer you can reach
What does a failure cost?	An hour of cleanup	A missed shipment or a bad invoice

Low-code platforms are genuinely capable. Microsoft’s own documentation describes Power Automate as low-code automation you build with a visual designer, and the pattern is the same across Zapier and Make: pick a trigger, pick an action, map the fields, turn it on. Pricing typically runs from free tiers for a few hundred tasks a month up to roughly $20–$100 a month as volume grows, which is far cheaper than developer time for most flows.

You reach for a custom API integration when a low-code tool starts fighting you: the volume is too high, the timing has to be instant, the logic has too many branches, or the same connection breaks often enough that “fix it in the visual editor” stops being a five-minute job. That is the point to talk to someone who does [[Software development]] — not before.

When a manual export is fine, and when it’s a liability

Manual is not automatically bad. A manual export is perfectly reasonable when:

• It happens rarely — monthly or quarterly, not hourly.
• The volume is small enough to eyeball for errors.
• The data moves in one direction and nobody downstream is waiting on it in real time.

A construction firm exporting last month’s job costs into a spreadsheet for the owner to review is a fine manual process. It runs once, someone checks it, and being a day late changes nothing.

Manual becomes a liability the moment any of these creep in:

• Frequency. If someone does the export every day, the labor and the error rate both add up fast.
• Two-way flow. When both systems can change the same record, manual syncing guarantees they drift apart.
• Time pressure. If a shipment, an invoice, or a patient reminder depends on the copy happening, a forgotten export becomes a real-world failure.
• One person. If the process lives only in one employee’s head and their unwritten routine, you have a business risk, not a workflow.

The spreadsheet only Jane understands

Nearly every small business has a version of this: a spreadsheet, connected to nothing, that quietly runs something important — commissions, inventory, a client roster, the production schedule. It has formulas nobody remembers writing, a tab structure that made sense to one person, and a manual update step that only that person performs.

It works right up until Jane is on vacation, or leaves. Then the report is late, the numbers are wrong, and nobody can safely touch the file.

This is the most common and most dangerous integration gap in a small business, because it looks like it is working. The fix is not always to replace the spreadsheet. Sometimes it is enough to:

1. Write down what it does — its inputs, its outputs, and who depends on the result.
2. Move the manual steps into a documented, repeatable process at minimum, or a low-code flow if the source data lives in real systems.
3. Give a second person access and a walkthrough so the knowledge is not held by one human.

If that spreadsheet is really your reporting layer, the durable answer is to feed real systems into a proper dashboard. That transition is covered in [[From spreadsheets to dashboards]].

Data hygiene: the part that quietly decides everything

Integrations move data. If the data is messy, the integration moves the mess faster and into more places. A few habits prevent most of the pain:

• One source of truth per field. Decide which system “owns” the customer’s address, the price, the phone number. Everywhere else reads from that owner rather than holding its own copy.
• Consistent identifiers. If a customer is “Acme Inc.” in one system and “Acme, Incorporated” in another, no integration can reliably match them. Agree on an email address, an account number, or another stable key.
• Clean before you connect. Deduplicate and fix formatting in each system before you turn on a flow. Connecting two messy databases produces one bigger mess.
• Validate at the entry point. A required-field rule on your web form prevents a hundred bad records downstream.

Getting this right also pays off later if you start using AI, because these tools are only as trustworthy as the data feeding them. The [[Adopting AI in your business without losing control]] guide walks through that dependency.

A checklist to map your data flows this week

Before connecting anything, spend an hour mapping what already moves and how. Do this on paper or a whiteboard first.

1. List your systems. Every app, spreadsheet, and form that holds business data.
2. Draw the flows. For each pair, note what data moves between them, in which direction, and how often.
3. Mark the method. Label each flow: automatic, low-code, manual export, or a person retyping.
4. Flag the retyping. Every “person retyping” arrow is a candidate to automate — start with the ones that run most often.
5. Flag the single points of failure. Any flow that depends on one person’s memory or one undocumented file. These get fixed regardless of automation.
6. Name the owner of each field. Where two systems hold the same data, decide which one is authoritative.
7. Pick one flow to start. Choose the highest-frequency, lowest-risk retyping task. Automate that one, watch it for a week, then move to the next.

You will usually find that two or three flows account for most of the manual work. Fix those and the daily grind drops noticeably.

Watch-outs that bite people

• Silent failures. An integration that stops working without telling anyone is worse than no integration, because people assume it ran. Turn on failure notifications and check the flow’s run history weekly for the first month.
• Duplicate loops. Two-way syncs set up carelessly can echo a change back and forth, creating duplicate records or an endless loop. Start every connection one-directional and only add the reverse once you have watched it behave.
• Over-automating too soon. Do not wire up fifteen flows in a weekend. Each one you add is something to maintain. Automate the painful few, document the rest, and leave the genuinely rare tasks manual.

Your next step

Map your data flows using the checklist above, then automate one high-frequency, low-risk task with a low-code tool and watch it for a week. When you hit a connection that low-code can’t handle cleanly — high volume, real-time timing, or logic that keeps breaking — that is the moment for a purpose-built integration. Our [[Software development]] work is built for exactly those connections, and we’re happy to look at your flow map with you.