Now officially Built for Shopify

Checkout Components just hit a huge milestone: we’re now officially Built for Shopify.

I’m honestly pretty damn proud of this one.

This wasn’t a rubber-stamp achievement. It forced us to rethink big parts of our product – from UX flows to error handling to how fast every route and component loads – and the app is significantly better because of it.

What “Built for Shopify” actually means for us

Shopify’s Built for Shopify program is their highest quality bar for apps – it’s about performance, design, and deep integration into the Shopify admin. To get the badge, your app has to meet strict requirements around things like Web Vitals in the admin, not tanking storefront performance, and aligning with Shopify’s design and integration standards.

In plain English: if you see that badge, Shopify has already gone through your app and said, “Yep, this is up to our standard.”

For Checkout Components, that meant:

-Bringing our UX and UI in line with Shopify’s guidelines

-Hitting aggressive performance targets (LCP, INP, route load times, etc.)

-Proving we don’t hammer storefront or checkout speed

-Tightening up integration so everything feels native in the admin, not bolted on from the outside

Reworking the UX to meet (and exceed) the standard

One of the biggest changes we made was around how the app actually feels to use.

To meet the Built for Shopify criteria, we had to embrace their UX patterns more aggressively: navigation, page layouts, forms, save behaviour – all the things merchants subconsciously expect to “just work” the same way across the admin.

Concretely, that meant:

-Refactoring our navigation to behave like a first-class citizen in the Shopify admin

-Simplifying flows around creating and managing components so you can get from “idea” to “live checkout upsell” with fewer steps and less noise

-Making the app home more useful – surfacing key metrics and entry points rather than just being a fancy landing page

-Tightening copy and reducing decision fatigue at each step

This wasn’t just a compliance exercise. The more we leaned into Shopify’s patterns, the more obvious it became: our old UX was making merchants think too much.

Now, the app feels cleaner, more predictable, and closer to the rest of the admin. If you already know how to navigate Shopify, Checkout Components should feel familiar in a good way.

Built for Shopify completely reshaped our UI

Doing this properly meant not just “tweaking” the existing UI, but asking some hard questions:

-Are we using the right components in the right places?

-Are we over-designing screens where merchants just want to get something done?

-Are we being clever with layout at the cost of clarity?

We ended up:

-Standardising on Shopify’s design language so our screens feel native, not like a separate product living inside an iframe

-Cleaning up spacing, typography, and hierarchy so the important actions actually stand out

-Consolidating settings and actions so you’re not hunting through multiple places to manage a single component

The result is a UI that is simpler, sharper, and faster to scan. Built for Shopify forced us to clear out a lot of historic cruft that had built up as we shipped fast over the last few years.

Honestly: if Shopify hadn’t pushed us this hard, we probably would have lived with “good enough” for longer than we should have.

We didn’t get approved on the first try (and that’s a good thing)

This wasn’t a one-and-done submission.

We went through multiple rounds of review, feedback, and resubmission. Each time we thought, “This is the one,” Shopify came back with more detail: minor UX inconsistencies, performance edges we hadn’t optimised yet, flows that could be clearer, places where we could better align with their patterns.

Annoying? Sometimes. Valuable? Absolutely.

Each rejection forced us to:

-Tighten navigation and routing logic

-Clarify edge cases in flows

-Strip out anything hacky that had snuck in over the years

-Fix “it works, but it’s not great” areas we’d mentally deprioritised

By the time we finally got the Built for Shopify approval, the delta between where we started and where we landed was huge. The badge is nice, but what I’m most proud of is how much better the product now is for merchants.

Rebuilding error handling from the ground up

One of the biggest internal changes was our error handling.

Historically, like a lot of fast-growing apps, we had a mix of:

-Generic “something went wrong” messages

-A few helpful errors

-Some silent failures that only really surfaced in logs

That’s not acceptable at Built for Shopify level – and it’s not acceptable for the kind of merchants we serve, either.

So we rebuilt our error handling system end-to-end:

-Clear, human-readable messages that explain what happened and what to do next

-Better mapping between backend errors and front-end states

-Safer fallbacks, so a partial failure doesn’t wreck the entire experience

-More graceful handling around network issues, timeouts, and edge cases

It’s one of those changes most people won’t notice consciously when things are working – and that’s the point. But when something does go wrong, the experience is calmer, clearer, and far less frustrating.

Hitting the performance bar: components, routes, and speed

Built for Shopify has tough performance expectations – especially around Web Vitals in the admin and limiting the impact on storefront speed.

To meet that bar, we had to get serious about:

Component performance:

-Reducing unnecessary re-renders

-Breaking down heavy screens into smaller, more focused components

-Lazy-loading non-critical parts of the UI

Route performance:

-Optimising data fetching so we’re not over-fetching or serialising huge payloads

-Caching where it makes sense, without risking stale or misleading data

-Trimming initial payloads to keep LCP and INP where they need to be

Overall app footprint:

-Dropping dependencies we didn’t really need

-Cleaning up old code paths and unused experiments

The end result: routes load faster, interactions are snappier, and the app “feels” more responsive across the board, which is exactly what Shopify is trying to enforce with this program.

What this means for our merchants

From a merchant point of view, here’s what this actually changes:

You get a smoother, faster admin experience.
-Less waiting, less jank, fewer “what the hell just happened?” moments.

The app feels more like Shopify, not a bolt-on.
-If you know how to use the admin, you’ll feel at home inside Checkout Components.

Things are more resilient.
-Better error handling, clearer messages, and fewer dead ends.

More trust from the ecosystem.
-The Built for Shopify badge isn’t just a logo; it’s Shopify publicly stating that we’ve met their highest standards and passed their audits.

And for us, it pushes the standard higher. We can’t ship anything that drags the experience backwards now – the bar is set, and we intend to keep raising it.

Looking ahead

Getting Built for Shopify isn’t the finish line. It’s a checkpoint.

We’re going to keep:

-Improving performance as we add new features

-Tightening flows so creating and optimising checkout experiences is as fast as possible

-Doubling down on resilience, observability, and merchant trust

But for today, I’m taking a moment to be proud.

Checkout Components is now Built for Shopify, and the product is better in every meaningful way because we did the hard work to earn it.