Integrations

The short version

You bought good tools. A CRM, an accounting package, a payment processor, an email platform, maybe a shipping account. Each one is fine. None of them talk to each other, so somebody on your payroll has become the integration — reading from one, typing into the next, and being blamed when a number does not match.

• The cheapest software project available to most small businesses is connecting the systems they already pay for.

• Most single integrations come in under $5,000 and take two to three weeks.

• The hard part is never the happy path. It is what happens when the other end is down, slow, or has changed.

• No-code tools are the right answer for simple, low-volume, low-stakes links, and there is a table below for working out which you have.

• Whatever we build, the credentials and the accounts stay yours.

How to tell a person has become the integration

The tell is copy and paste. Someone finishes a job in one system and immediately opens another to record that the same thing happened. Nothing is being decided; information is just being carried.

The usual symptoms:

• A daily or weekly "sync" that is really a person exporting a CSV and importing it somewhere else.

• Two systems that disagree about how many customers you have, and nobody knows which is right.

• Orders that exist in the store but not in accounting until Thursday, because Thursday is when somebody sits down and keys them in.

• A customer told "let me check with the office" for something one of your systems already knows.

• Month end taking three days, most of which is reconciliation, not analysis.

The cost is not only the hours. It is the delay — every manual sync means some part of your business is looking at yesterday's picture, and decisions get made on it.

What we connect

Anything with an API, which by now is most business software. The ones small and medium businesses ask for most:

• Payments — Stripe, PayPal, Square and the rest: charges, refunds, subscriptions, failed payment handling, and webhooks reconciled against your own records.

• Accounting — QuickBooks, Xero and similar: invoices, credit notes, payments and customers pushed across so nobody rekeys them.

• CRM — HubSpot, Salesforce, Pipedrive: leads in from your website, deal stages kept in step with what the operational system knows.

• Email and messaging — transactional mail, marketing platforms, SMS notifications that fire on real events instead of on someone remembering.

• Shipping and logistics — labels, rates, tracking numbers pushed back to the customer automatically.

• Everything else — suppliers' portals, industry-specific platforms, and the ancient system with a flat file drop that still runs half the business.

When something genuinely has no API, there is usually still a route: a scheduled file exchange, an emailed report parsed on arrival, or a database read. It is less elegant, and it still beats a person retyping.

Why integrations are harder than they look

Because connecting two systems on a good day is an afternoon. Connecting them so that they are still right after a bad day is the actual job, and it is where the budget goes.

What has to be handled:

• Rate limits — every API will cut you off if you ask too fast, usually during your busiest hour.

• Partial failure — the invoice was created and the payment record was not. Now what?

• Idempotency — a retry must not create a second invoice or charge a card twice.

• Ordering — the update arriving before the record it updates, which happens more than you would think.

• Reconciliation — a scheduled check that both sides still agree, because eventually they will not.

• Authentication that expires — tokens rotate, and a silent expiry at 2am is a classic Monday morning surprise.

The rule we build to is that an integration must never lose data and must never act twice. Everything else — speed, elegance, cleverness — comes second to those two.

Zapier and Make are often the right answer

Sometimes, genuinely. We will suggest it whenever it fits, and yes, that costs us work — which is exactly the point. No-code automation platforms are excellent at simple, low-volume, low-stakes connections and they are available this afternoon.

The point where people switch is usually cost or debuggability. Per-task pricing is cheap at a hundred tasks and unpleasant at fifty thousand, and when a no-code flow silently fails, working out why is often harder than having written it properly.

What an integration costs

Small automations and integrations often come in under $5,000, and most are done in two to three weeks. Bigger jobs — several systems, two-way sync, a historical backfill — are quoted after a short call.

Two things move the price more than anything else: whether data flows one way or both, and how good the other end's API is. Two-way sync means deciding who wins when both sides changed the same record, and that is a business rule you and we have to agree on, not a technical detail.

What we need from you to start

Less than people expect, but the bits we do need tend to be the bits that hold projects up, so it is worth knowing early:

• API access on accounts you own, created by you, not by us. Your integration should never depend on a developer's personal login.

• A sandbox or test account where one exists, so nothing is proved against your live orders.

• A person who can answer questions about the business rules — which field means what, and what should happen when the two systems disagree.

• A sample of the real data, including the ugly records. The awkward ones are the requirements.

• Whichever plan tier the provider hides API access behind. Occasionally that is the deciding cost, and better found in week one than week four.

We set the credentials up with you instead of asking you to email them, and everything lives in your accounts from the start. That way an integration is never something you would have to unpick if you stopped working with us.

When their API changes

It will. Providers deprecate versions, change field names and occasionally retire endpoints with a few months' notice buried in an email to an address nobody reads.

How we reduce the damage:

• Pin to a specific API version instead of tracking whatever is current.

• Isolate each provider behind one piece of code, so a change is one file, not a hunt.

• Monitor the integration itself, so a break is noticed by us, not by your customers.

• Keep the credentials in accounts you own, so nothing is hostage to our access.

If your integration is covered by the Anvil Care Plan, keeping up with provider changes is part of it. If you would rather run it yourself, that is fine too — it is documented, and the code is deliberately boring enough for any competent developer to pick up.

Naming the two tools and the thing that has to move between them is usually enough to say on a first call whether this is a two-week job or a project — and whether a no-code tool would do it for a fraction of the price.