Have to pivot? Good.

I’ve built two things to about two-thirds done and then pivoted. Not because they didn’t work. Both of them worked. I walked away because of what I learned each time about the part that isn’t building, which is getting anyone to actually adopt the thing.

There’s a clip of Jocko a lot of people have seen. He’s a former Navy SEAL, so it’s about as intense as two minutes of video gets. Someone brings him a problem and his entire answer is one word: good. Mission got cancelled? Good. Didn’t get the promotion? Good. Now you know something you didn’t, or there’s an opening you wouldn’t have found otherwise.

I love the reframe, and I choose to hold it a bit more lightly than he does. Every time I’ve had to pivot, once the sting wears off, the honest reaction lands on the same word. Good. Here’s the fun, low-stakes founder version of that.

▶ PLAY

LayerKick is the third attempt at finding product market fit within the Shopify ecosystem, and it only makes sense if you know the first two. So here’s the honest version of how I got here, pivots and all. If you’re a founder, you probably know the specific feeling of being genuinely excited about something and slowly realizing the problem was never the code.

The upsell app

The first one was Sprout, a Shopify app for cart-tier unlocks and upsells. The waitlist site is still up if you want to see where my head was at.

The edge was real. It took something that already existed and made it 10x better, and it wasn’t a guess, because every one of my freelance clients had asked me for cart-tier capabilities. I got maybe two-thirds of the way through building it.

Then I hit the trough of disillusionment, and it taught me something about Shopify I hadn’t appreciated. Shopify’s checkout is the same everywhere. Every store’s checkout behaves identically, because Shopify owns it. But the slide-out cart, the little drawer that opens when you add something, is different on every single theme. Every theme builds its own. So an app that has to reach into the cart drawer and add tier logic runs into a genuinely infinite number of situations, one per theme, and then one per theme customization on top of that.

About halfway through fighting that, I understood why nobody had built the great universal version. Everyone was just rolling their own slide-out cart instead, and some of them baked the tier features right in. They get more stability that way, and more features they can offer to make more money. So what I was actually looking at was market saturation, plus a ton more work, at a time when AI could write code but couldn’t yet carry a project like this. This was pre-December, before Opus 4.6, the turning point. The fragmentation that made my app valuable in theory was exactly what made it impossible in practice. I could keep patching per-theme forever, or I could accept that the universal-app shape was not the fight I wanted.

The theme

So I went the other way. If the theme is the problem, own the theme.

That became Threshold, and this is one I was really excited about. It was a Liquid theme that turned into a Hydrogen site, Shopify’s React-based storefront framework, more or less magically, because of the first version of a transpiler I was building. The transpiler took Liquid, the templating language Shopify themes are written in, and turned it into modern components. Watching a Liquid theme become a Hydrogen site through a pipeline I wrote was one of the more satisfying things I’ve built.

I got about two-thirds through this one too. The product page was done. The homepage was done. I was building components one at a time, and the part I loved was designing a reusable structure that converted intuitively from Liquid into Hydrogen, so each new component got easier instead of harder.

And then, again, I walked away. Not because it didn’t work. It worked, and honestly it was beautiful. I walked away because of a sales decision.

Asking a merchant to migrate their whole theme is an enormous ask. Even if the destination is better in every measurable way, migration is scary, it’s expensive, and it’s the kind of project a store puts off for a year. I think Threshold could have worked if I’d committed to it fully, brought on designers, and made it a genuinely premier theme, because I was already building it to that bar. But that path needed a mountain of sales and marketing to get adoption, and sales is the exact thing I’m weakest at.

My plan had been to sell it through agencies. If agencies adopted the theme, then every new site they built for a client could instantly be on Hydrogen, which would have been an unfair advantage for them. It’s a good plan. It’s also a long, relationship-heavy sales motion, and I was one technical person. The theme was going to live or die on adoption I wasn’t equipped to drive.

The layer

Here’s where it turned into LayerKick, and the turn came from taking the two lessons seriously at once. Lesson one: don’t depend on a surface that’s different on every store. Lesson two: reduce the objections as much as possible.

The question I started asking was smaller and better. What if I don’t replace the theme at all? What if I just insert a layer in between the shopper and Shopify, take over the parts that benefit from being taken over, and leave everything else exactly where it is?

It started as a narrow idea: use the transpiler to get access to the theme, but only selectively rebuild the specific pieces that needed to change for a given customer. Then I realized something that made it much simpler. Most of what a modern storefront does is already client-side anyway. So I didn’t need to selectively rebuild much at all. I could just put a caching layer in front by default, serve the store faster, and only reach for the transpiler where it actually earned its keep.

And once I had that layer, everything compounded. Being the layer that renders and serves the page meant insights were nearly free and testing was nearly free. The narrow caching idea spun out into the whole thing.

What actually carried over

The neat part, looking back, is that almost nothing was wasted. The transpiler I built for Threshold is the same engine that lets LayerKick render a merchant’s theme at the edge today. The cart-drawer fragmentation I learned the hard way with Sprout is exactly why LayerKick is careful about what stays client-side. Two abandoned projects, and the durable pieces of both are load-bearing in the one that stuck.

The through-line I didn’t see until I wrote it down is that every wall I hit was a sales wall, not a technical wall. Sprout died on adoption. Threshold died on migration. LayerKick is, in a real sense, the version designed around my own weakness: the smallest possible ask, layered on top of the store you already have. No theme rebuild, no replatform. If your DNS isn’t already on Cloudflare, pointing it there is the whole move. It turns out designing for “the founder is bad at sales” is a decent product constraint. It forces you to make the thing that sells itself.