The 80% You're Not Optimising

Your tech stack isn't your edge anymore.

Everyone's running the same tools. Same CRM. Same ad platforms. Same reporting. HubSpot, Monday.com, Slack, Klaviyo, Meta, Google, Looker Studio, Power BI.

There's zero edge in the tools. Maybe 20% in how you use them - or the brains you forked out an extra $30k a year for. The other 80%? It's hiding in the gaps between them - the workflows no one questions because "that's just how we do things."

And if you're the person who knows that complicated process inside out? This could go two ways.

You either become the blueprint - the one who knows exactly what to build because you've felt the pain for years. That knowledge stops being survival and starts being leverage to your next promotion.

Or you protect the process because your value is tied to it. And someone else walks in and builds the fix anyway. We've seen it go this way. It's not pretty.

The transformation is coming either way. The only question is whether you're driving it or watching it happen.

The gaps are where time goes to die

Every business has them. The weird, specific, industry-only problems that live between your tools. The workflow you've duct-taped together with spreadsheets and email chains. The process that works but bleeds time every single week. And falls apart the moment someone forgets a step, takes leave, or gets the flu.

You know the ones:

• The Monday morning ritual of pulling data from three systems into one report
• The approval process that lives in email threads no one can find
• The client onboarding that's 40% admin and 60% apology for the admin
• The quoting process that requires a senior person because "it's complicated"

These aren't software problems. They're your problems. And that's exactly why no one's solved them.

No software company is coming to fix it. The market's too small. Maybe 500 businesses have this exact problem. That's not a venture-scale opportunity. So it doesn't get built.

The economics never made sense. Until now.

The economics flipped

Here's what changed: AI collapsed the cost of building.

What used to take a team of engineers and a year of runway now takes a week. Sometimes a day. The capital required to build software dropped by 90%. The time dropped further.

Suddenly those "too small" problems are buildable. Fast. Cheap. By people who understand the problem - not just people who can write code.

This is the shift most businesses are missing. They're still thinking about AI as a feature inside their existing tools. "My CRM has AI now." "My email platform has AI now."

That's not the game.

The game is that building itself got cheap. The problems that were too niche, too specific, too "not worth it" - those are all on the table now.

The tool that's never going to see the light of day outside your company - and nor should it.

A decade ago, "custom-built" was a red flag. Custom website? Nightmare to maintain. Custom software? Money pit. You went with WordPress, with Salesforce, with the safe option. And you were right to.

But that was when custom meant expensive, slow, and fragile. When it required a dev team and a six-month runway.

Now? Custom means Tuesday afternoon.

The rise of the micro-tool

We're entering the era of the micro-tool. Small, focused, solves one problem.

Not a platform. Not a suite. A scalpel.

You don't need software that does 50 things, 47 of which you'll never use. You need something that fixes the one workflow that's bleeding time. That's it.

The old world made you adapt your business to the software. The new world lets you build software that adapts to your business.

A word on "vibe coding"

There's a term floating around: "vibe coding." Often used dismissively. The implication is that non-technical people prompting AI to build things aren't "real" builders. It's not "proper" engineering.

Here's the counter: vibe coding is the only coding that ever mattered.

The "vibe" is the hard part. It's knowing what to build. It's pattern recognition. It's spotting the workflow that's bleeding time, understanding why it's broken, and having the taste to know what "fixed" looks like.

Code was never the point. Code is implementation. The bottleneck was always: do you understand the problem deeply enough to solve it?

For decades, that understanding was trapped. The person who knew the problem couldn't build. The person who could build didn't know the problem. So we got generic solutions for generic problems.

Now? The domain expert can build. The operator can build. The person who's felt the pain for ten years can finally do something about it.

That's not a downgrade. That's an unlock.

The engineer who can write beautiful code but doesn't know what to build? They're in trouble. The operator who knows exactly what's broken and can now prompt their way to a solution? They're dangerous.

Vibe coding isn't amateur hour. It's the point.

And yes - vibe coding gets you 80% of the way there. The last 20% might still need someone with technical skills to check the wiring, tighten the screws, make sure it doesn't fall over at scale. But paying for a review is a lot cheaper than paying for the whole build. The expensive part - knowing what to build - is already done.

Here's a question worth asking

Where's your duct tape?

Every business has processes that "work" but everyone quietly hates. The ones you've stopped complaining about because complaining didn't change anything.

Three ways to find them:

1. What's held together by email chains?

If approvals, feedback, or handoffs live in inboxes, that's a gap. Email is where process goes to hide. It feels like communication, but it's actually a system - just a bad one.

Look for threads with more than five replies. Look for the things you have to search for every time. That's a tool waiting to be built.

2. Where do you re-key data between systems?

Copy-paste is a symptom. The gap is the integration that doesn't exist.

Your tools don't talk to each other because the vendors don't care about your specific workflow. They built for the average case. You are not the average case.

Every time someone manually moves data from A to B, you're paying for a bridge that should already exist.

3. What do you complain about but assume can't be fixed?

This is the big one.

That resignation - "it's just how it is" - is a signal. It means you've accepted friction that doesn't need to exist. It means no one's built for this yet.

Most businesses have two or three of these. Hiding in plain sight. Costing hours every week. Dismissed as "just part of the job."

They're not. They're opportunities.

A real example

We found a 10-week-per-year time suck hiding in an ad approval process.

Not a sexy problem. Not something a VC would fund a startup to solve. Just a specific, annoying workflow that every ad agency deals with and no one's built for - because the market's too small for the big players to care.

The old flow: Take screenshots of ads. Build a PDF deck. Email to client. Client reviews, emails back changes. Rebuild the PDF. Email again. Repeat until approved. Then manually update the ads.

Not broken. Everyone does it this way. Just slow. And so specific that no tool existed for it.

We mapped the time:

• 300+ approval cycles per year
• ~105 minutes each
• 10+ weeks of work annually

The new flow: Upload screenshots, AI extracts the copy, client clicks a link, edits directly, approves. Changes tracked. Download ready. Done.

~28 minutes per cycle. 77 minutes saved each time. 8 hours back every single week.

Built in days, not months. Not because we're geniuses. Because the economics finally made it possible.

What this means for your business

You have two options:

Option 1: Wait for your vendors.

Hope that Salesforce, HubSpot, or whoever adds the feature you need. They might. In two years. Designed for the average user, not you.

Option 2: Stop waiting.

Identify your gaps. The specific, painful, "too small to matter" problems. And recognise that "too small to matter" was a funding constraint, not a technical one. That constraint is gone.

The best opportunities aren't in your tech stack. They're in the spaces between it.

Your competitors have the same tools you do. They don't have your gaps solved.

That's the edge.

The bottom line

Software used to be a moat. Now it's a commodity. The differentiator isn't which tools you use - it's whether you've fixed the things those tools don't touch.

Stop shopping for better software. Start being a surgeon. Find the one process that's bleeding time and cut it out.

The problems that were too small to solve aren't too small anymore. They're just unsolved.

The question is whether you'll fix them, or keep working around them until someone else does.

‍