Fewer Steps, Fewer Errors, Lower Costs

Find every place a job is copied from one tool into another. Then cut the step, the tool, or both.

By James Schramko · Updated October 2026

I paid for software as a service for twenty years. A tool for the customer database and the email. A tool for support. A tool for files. A tool to connect the tools. A tool to host the website. Some cost a little. Some cost a lot. Each one added a step. At one stage I was paying $1,000 a month for hosting. Today I pay $0.

This year I pulled most of them out. More than $10,000 a year in tools went. Count the hosting, the domains I am letting go and everything else, and it is tens of thousands a year, before counting the wages tied to running those tools. The jobs got faster and the errors dropped.

Software as a service is being compressed. The tool that did one job for a monthly fee is now a step a system can run on its own. If you still pay for ten of them, the cost is the small part. The steps are the big part.

Who This Is For

You pay for ten or more tools.

Every job in the business touches three of them before it is done.

Someone on your team copies from one screen into another every day.

You are reasonably capable with Claude Code, which is just about anybody these days. You do not need to be an engineer. Being able to describe a job and check the result is enough.

The Test

Walk through one job from start to finish. Any job. A customer email, an invoice, a weekly report.

Mark every point where there is pain. Pain is any one of these.

Double handling. The same information typed or pasted twice.

Copy and paste. Anything that moves from one tool to another by hand.

Bureaucracy. An approval queue, a sign-off, a form that exists because the tool needs it.

Time delays. A wait for a person, a sync, a file to land.

Missing data. A record that should have arrived and did not, so someone goes looking.

Broken links in a long chain. Five tools joined end to end, and one of them fails. The job stops and nobody knows which link went.

Each mark is a pain point and a candidate. A job with six marks has six places to lose time, make an error, or pay for a tool.

What I Removed

The CRM software. The file storage. The integration software that joined the tools together. The support software. The website hosting software, and the website platform it hosted, with the old backups still sitting on a server. Dozens of domains I was renewing out of habit.

Then the wages. Every one of those tools had a person touching it: logging in, moving things across, checking it still worked, chasing the vendor when it did not. That time is a cost the subscription never shows you.

Each tool was doing a job. Each job now runs with fewer steps.

The CRM is the clearest example. For years my customer records, my email list and my billing lived inside one subscription, on a vendor's terms. I could not see how it worked, I could not change it quickly, and when it went down I waited. Now the records live in a file I own, the sending runs through a plain email service, and billing runs direct. I took back control. The jobs got faster. The data got more accurate, because there is one copy instead of three. Nothing is copied across because there is nowhere to copy it to.

The email broadcast shows the before and after. Before: a file in a shared folder, posted to the team chat, pasted into the email tool, a test send, an approval, then send. Five hand-offs. Now: my system drafts the email, loads it, sends the test, and a team member types one word to ship it. The first send on the new path delivered to 100 percent of the list.

Invoices used to be a request to a person. Now clients open a billing page and get their own. One step, no wait.

One more thing changed. Most tools do a lot of things, and you use one part. You pay for the whole and you work around the rest. Now you can craft the one bit you need, without all the other bits. A form that does exactly your form. A report that pulls exactly your numbers. The tool you were paying for was a bundle. You only ever needed one item from it.

The Method

Step one. List the pains. Walk your five most common jobs with the test above. Write down every point of friction, every slow point, every place someone waits or goes looking. This list comes first because it is the real cost. The tool bill is the shadow it casts.

Step two. Map every tool and what it costs. Annual figure, not monthly. Then reconcile the overlap. For each tool, write what it can do and what you use it for. Lay them side by side like a Venn diagram. You will find three tools that store files, two that send email, and four that each do one small thing you could not get elsewhere at the time. The overlap is where the cuts are. The total is usually a surprise.

Step three. Pick one core. One place the information lives. Connect the other tools to it directly, or remove them. Reporting, posting, email, editing, support and billing can all run from one core.

Step four. Run old and new side by side. Do not cut the old tool on day one. Let the new path prove itself on real jobs for a few weeks.

Step five. Cancel at renewal. Export what you need first.

Step six. Measure steps, errors and time before you measure cost. The cost drop is the by-product. A job that went from five hand-offs to one is the result.

What Changes

Jobs finish the day they start. The report that took a week arrives in minutes. The email that needed four people needs one word.

Errors drop because the places errors lived are gone. Nobody pastes the wrong version. Nobody sends the test to the list. Nobody hunts for the record that never came through.

Roles that existed to move information between tools change. The work that remains is judgment: what to send, what to approve, what to stop.

And the bill drops. In my case by tens of thousands a year, with better results on every job it touched.

Common Mistakes

Cutting the tool before the path is proven. Run both. Then cut.

Buying a new tool to remove an old one. If the new tool adds a step, you have moved the pain.

Measuring cost first. The subscription is the visible number. The pain is the real one.

Keeping a tool because it is paid for the year. Sunk cost. Export, cancel at renewal, move on.

Keeping a tool for the one feature you use. Build the one feature. Drop the bundle.

Quick Reference

Walk one job end to end. Mark every pain: double handling, paste, queues, waits, missing data, broken links.
Map every tool with its annual cost. Reconcile the overlap.
Pick one core. Connect to it or remove.
Old and new side by side, then cancel at renewal.
Measure steps, errors and time first. Cost follows.

This is the same cut as Growth Follows Subtraction, applied to the tools. Working out which tool is a step and which is a crutch is hard from inside the business that bought them. That is work I do with owners inside Mentor.