The short version: if a developer quotes you a one-time price for custom Shopify work and calls it done forever, one of two things is true. They don't understand how Shopify works, or they're leaving the real cost out of the quote. Shopify retires the platform versions that custom code is built against on a rolling schedule, roughly every twelve months, so every custom feature on your store is quietly on a clock. The honest quote has a maintenance line in it. The cheap one without it doesn't remove that cost; it just moves it to you, later, at a worse moment.
"Build once, run forever" is a pitch, not a product
Here's the pitch you've probably heard, in one form or another: pay once, own it forever. No monthly app fees. Custom code is yours.
It's an appealing pitch, and the ownership part is genuinely true. Custom code doesn't charge you rent the way an app does, and it travels with your business. But the forever part has never been true of any software, and on Shopify specifically it now has an expiry mechanism you can point to in the platform's own documentation.
I watched this play out in a private community of Shopify developers I'm part of. A developer who had sold merchants custom apps as build-once-use-forever described what that promise had turned into: every time one of those merchants asks for a small change now, he has to spend hours migrating the old code to the current platform first, before he can even start the change they asked for. Another developer in the same thread put the general truth plainly: "No software in history has been build once, use forever."
That's the honest version. Here's why it's true on Shopify, in plain English.
Your custom work is built against a version, and versions expire
Every piece of custom code on your store, whether a custom app, a checkout customization, or an integration, talks to Shopify through what's called an API: the set of rules for how outside code reads and changes things on your store. Shopify releases new versions of those rules on a regular schedule, and supports each stable version for a minimum of twelve months. After that, old versions get retired.
This isn't a policy that only matters to developers. It has teeth: Shopify's own tooling blocks developers from deploying updates to extensions built on a version more than twelve months old. Not "discourages". Blocks. The code keeps running, but the moment anyone needs to change it, they first have to bring it up to a current version. Your custom feature didn't break; it went stale, and staleness has a price that someone will pay.
There's a live example of this happening right now, and it's worth understanding because it's the clearest exhibit I've seen of the mechanism.
The live exhibit: checkout customizations built the old way
For years, the standard way to build checkout customizations on Shopify used a popular coding framework called React. Per Shopify's own documentation, the July 2025 platform version is the last one that supports checkout extensions built that way; everything after it uses a different approach. Combine that with the twelve-month rule above, and every checkout customization built the old way is sitting inside a closing window: once the July 2025 version ages out, no updates can ship until the code is migrated to the new approach.
To be precise about what's published and what isn't: Shopify has not announced a specific cutoff date for this. What's documented is the mechanism, the last supporting version and the twelve-month support floor. Developers in the community I mentioned have done the arithmetic and are working to a window of roughly mid-to-late 2026. Treat the exact date as unconfirmed; treat the mechanism as certain.
Now re-read that developer's complaint with this in mind. He sold "build once, use forever." The platform moved underneath the promise. And every merchant who bought that promise now owns a feature where the next small change starts with hours of unpaid-for migration work, and a conversation nobody budgeted for about who pays for it.
It's not just checkout
The same pattern shows up across the platform, continuously:
- Collections. Shopify shipped a significant upgrade to how collections work in its 2026 platform versions. Shopify's changelog for the new collections model spells out the catch: on earlier API versions, collections using the new features are filtered out of the results entirely, so an older integration simply can't see them: the store works fine, but an older custom integration looks straight through the new data. The upgrade is good news; the point is that "finished" integrations get bypassed by a platform that keeps moving.
- App plumbing. Even the mechanics of owning custom work carry platform rules most one-time quotes never mention. Developers in that same community flagged, for example, that moving a custom app between hosting arrangements isn't a transfer. It's an uninstall and a reinstall, and uninstalling an app removes the live logic it registered on your store along the way. Sequenced carelessly, a "simple handover" can switch off checkout rules your customers rely on.
- Subscriptions. If your custom or app-based subscription setup ever needs to move to a different app or a different architecture, there's a whole careful migration sequence (Shopify documents it) where the central risk is double-billing your subscribers. Exit has a cost, and it should be priced in on the way in, not discovered on the way out.
None of these are Shopify doing something wrong. A platform that improves constantly is exactly what you want to build a business on. But it means every custom surface on your store is, functionally, a subscription to platform change, whether or not anyone priced it that way.
The incentive behind the cheap quote
If the expiry mechanism is documented, why do one-time forever quotes still exist? Because they win bids.
A developer quoting honestly has to include the ongoing cost of keeping your custom work current. A developer quoting to win has an easy trick available: quote only the build, say nothing about what happens in twelve months, and be cheaper on paper. The maintenance cost doesn't disappear. It transfers to you, and it comes due at the worst possible time: not on a schedule you planned for, but the day you urgently need a change and discover the change can't ship until a migration happens first. Deadline pricing, surprise scope, no leverage.
That's the arithmetic behind the title of this piece.
The quote with no maintenance line isn't cheaper. It's the same cost with the second half hidden, deferred, and marked up by urgency.
How to read a custom-work quote
You don't need to become technical to protect yourself here. You need four questions and one expectation.
Ask these before you sign off on any custom build:
1. "What platform version is this built against, and what happens when that version is retired?" Any developer working on Shopify should answer this fluently. A blank look is your answer.
2. "When Shopify changes the part of the platform this touches, who does the migration, and who pays for it?" You want this answered before the build, in writing, not negotiated during an emergency.
3. "If I ever need to move, replace, or retire this, what does the exit look like?" Handover mechanics, subscriber migrations, what gets switched off along the way. An honest developer will name the exit costs; the pitch-driven one will tell you there aren't any.
4. "Why is your quote cheaper than the others?" Sometimes there's a good answer. But if the gap is explained by a missing maintenance line, you've found where the real cost is hiding.
And the expectation: an honest quote for custom Shopify work includes what I'd call a platform-currency line, a modest recurring allowance for keeping the work current as Shopify moves. It might be framed as a maintenance retainer, a quarterly check, or an annual currency pass. The framing matters less than its existence. Its presence tells you the developer understands the platform they're building on and intends to be there when it moves. Its absence tells you the twelve-month clock is your problem now.
The bottom line
Custom work on Shopify is still one of the best investments a growing store can make. It's how you get functionality that fits your business instead of renting an approximation of it from an app. But it's an investment in a living platform, not a purchase of a finished object. Shopify retires the versions your custom code depends on, on a published rolling schedule, and its tooling enforces the deadline. That makes every custom feature a relationship with platform change, not a one-time transaction, and it makes the maintenance line the most informative line on any quote you'll receive. The developers who put it there are telling you the truth about the platform. The ones who leave it out are telling you something too.
I build and maintain custom work on Shopify and the connections around it: the ads, feeds, analytics, and integrations where platform change lands first. If you're weighing a custom-work quote and want a straight read on what it will really cost over its life, grab any slot that works and I'll walk through it with you.
