Connected, Not Cobbled

A small business runs somewhere between twelve and twenty pieces of software. One for the customer list. One for projects. One for the books. One for email campaigns, one for support tickets, one for files, one for chat, one for scheduling. Each charges by the head, by the month. Each holds a slice of the business. And none of them tell each other anything without a further subscription whose whole job is to carry messages between the others.

The total is invisible until somebody sits down and adds it up, and when they do, the instinct is to start cancelling. That instinct is wrong, and it is wrong in an interesting way. Cancel half of them and the work does not get easier. It gets harder, because the half that is left still does not talk to anything.

The cost that matters is in the joins. Client details retyped from the customer list into the project tool. The export and re-import between invoicing and the books. The fifteen minutes added to every internal question by the words "let me check the other system". None of it is a crisis. All of it happens every week, and it is the part no subscription line item ever shows you.

Paying per person sounds fair. You pay for what you use. It stops sounding fair the moment you notice that a business is not just its employees. There are contractors, suppliers, an accountant, a lawyer, and the clients themselves, and every one of them has a reason to look at something you hold.

Invite the contractor into the project tool and that is another seat for someone who logs in twice a week. Give the accountant a look at the numbers, another seat. Let a client check their own job status instead of emailing to ask, another seat. Three suppliers submitting invoices properly instead of attaching PDFs, three more.

So something happens that nobody decided. You stop inviting people in. Not for any reason to do with security, which would at least be a judgement. Clients go back to emailing for updates. The contractor works off an exported spreadsheet that was accurate on Tuesday. The accountant reconciles last month because last month is what they were sent.

That is the real bill, and it does not appear on the invoice. Access stops being decided on whether somebody being able to see a thing would help, and starts being decided on what the seat costs. We ran into exactly this in our own business and it is one of the reasons we moved off rented software: who sees the work now gets decided on whether it helps.

The question usually gets put as a choice between two things: rent it or run it yourself. That framing is what keeps producing disappointing answers, because it is a question about who hosts the software when the useful question is what the software is for.

Go through what your business actually does and almost everything falls into one of three piles.

Sorting your operation into those three piles is most of the work, and it is harder than it sounds, because the third pile is the one everybody gets wrong in both directions. Some businesses put nothing in it and end up indistinguishable from their competitors, running the same software the same way. Others put half the company in it and spend two years rebuilding a customer list that was never the point.

There is a version of this that treats open source as the budget option you settle for, and it does the tools a disservice. Twenty is a genuinely good customer list. Plane handles projects with real depth. Mattermost is proper team communication. People chose to build these and keep building them, and running one is not a compromise you are making to save money.

The same goes the other way, and it goes further than most people expect us to take it. We will tell a business to put its mail, documents and meetings on Google or Microsoft and pay for them, because that is the right answer and because the alternative leaves its mail, the most important part, exposed. Two of the tools we run our own business on are paid subscriptions for the same reason: somebody else being responsible is the point, not a compromise we settled for.

What matters is that each choice was made on purpose. The failure mode is not choosing wrong. It is a set of tools that assembled itself one emergency at a time, where nobody can now say why any particular piece is there.

Two examples, both from work that is written up in full elsewhere on this site.

A mortgage origination business had a landing page that was already doing its job. The one thing it needed was a set of bond calculators, and every calculator on the market was either expensive or felt wrong to use. So the calculators got built and nothing else did. The words on the pages went into a content system the client edits without asking anybody. The arithmetic stayed in code, where it can be tested. Those two decisions look like a technical detail and they are the entire architecture.

A platform for advocates offers three tiers of portfolio. The first two are curated templates, which is to say the ordinary pile. The third is built from nothing for one person, and it is deliberately not turned into a template afterwards. It is the tier that exists because some clients need something that is theirs, and it is priced accordingly.

Neither business built more than it had to. Both built the thing nobody could sell them.

Sorting the three piles gets you the right pieces. It does not get you a system. A customer list that tells the project tool nothing is a better-looking silo, and the friction from the first section is still sitting there.

The clearest version of this we have worked on is a medical equipment business whose software had been customised by two previous development partners until it could not take an upgrade. The third attempt changed nothing inside the bought parts. Everything standard stayed standard, on its published interfaces, and the two things that genuinely did not exist got built alongside it. That business is still on the current version and able to take the next one, which is the thing customisation had cost them.

That is what connected means in practice. Not one system that does everything, and not fifteen systems held together by somebody remembering to copy things across. Standard parts, left standard, talking to each other through the doors their makers put there, with the one thing that is yours sitting in the middle where it can see all of it.

Something has to move work between the standard parts, and there is a category of tool built for exactly that. n8n is the one worth knowing about: you draw the flow, map the fields, and it runs. It is a good piece of software, we are happy to run it for clients who want it, and for a business that mostly needs the ordinary pile joined up it will do a great deal of the job.

It is not what we reach for when the thing being built is the third pile. Drawing a flow gives you the moves the tool anticipated. Writing it gives you the ones it did not, which is where anything specific to one business tends to live. That is a difference in how much room you have rather than a difference in quality, and it only starts to matter at the point where the work stops being ordinary.

Which is the same distinction the whole article is about, arriving one layer down.