Will a Shopify Discount App Change Your Product Prices? Two Mechanisms Compared

Discount apps for Shopify are not all built the same way, and the difference is invisible until it isn't. Two apps can both promise "automatic discounts" while using completely different mechanisms under the hood — and the mechanism determines what happens to your catalog when things go wrong.

Full disclosure before anything else: we build Markdo, a discount app that uses Shopify Functions. We're going to describe both mechanisms as plainly as we can, including the trade-offs of our own approach, so you can judge for yourself.

Where a discount can actually live

When a discount shows up in your store, it has to come from somewhere. In the Shopify ecosystem there are two fundamentally different places it can come from.

Mechanism 1: writing to the price fields

Some apps change the price itself. They read your products through the Admin API, calculate a discounted price, and write it back into the variant's price field (or the compare-at price). This usually happens on a trigger — a schedule, a campaign start, a customer segment change — and a matching job resets prices when the campaign ends.

This approach has real advantages. The discounted price shows up everywhere automatically: product pages, collection pages, search results, feeds. No widgets, no theme changes, no visibility work. For some use cases — "sale prices" that should look like real prices — it's the natural mechanism.

The risk is symmetric to the benefit. Because the app now owns your prices, every price on your site is the result of an app-run pipeline: a trigger fired, prices were written, and somewhere a cleanup job is supposed to write them back. If any step of that pipeline fails — the app loses API access, a job is interrupted, the app is uninstalled before cleanup runs — the modified prices stay in your catalog. Your products are now permanently "on sale" or, worse, restored to the wrong value.

Mechanism 2: calculating at checkout

The other approach leaves your catalog untouched. Shopify Functions are small programs that run on Shopify's own infrastructure at checkout time. A discount app deploys a Function, and when a customer reaches the cart or checkout, Shopify runs it with the cart contents and the app's rule configuration, and the Function returns the discount to apply. Custom discount logic built this way is what powers automatic discounts created by apps.

Under this mechanism, the variant's price field is never written. The product page shows the full price; the discount appears in the cart and at checkout, the same way a discount code does.

The trade-off is visibility. Because the product page price doesn't change, an app on this mechanism needs something else to make the deal visible before checkout — promo badges, cart-drawer messaging, a progress bar. If an app takes this route and ships no visibility tools, discounts genuinely can go unnoticed until checkout. That is a fair criticism of the mechanism, and it's why we treat storefront widgets as a core part of Markdo rather than an afterthought.

What merchants report in reviews

You don't have to take our word for the failure modes. Public reviews on the Shopify App Store, across a number of discount apps, describe a recurring set of incidents:

• Prices that didn't revert after the app was uninstalled, with merchants discovering stale sale prices weeks later.
• Price updates that conflicted with market-specific pricing, so international customers saw wrong amounts.
• General reluctance to grant an app write access to price fields at all, after a bad experience with a previous app.

We're deliberately not naming the apps here — reviews describe incidents, not root causes, and any individual report can have its own context. But the pattern is consistent enough to treat as data: when an app writes prices, the failure mode is a corrupted catalog. When an app only calculates at checkout, the failure mode is, at worst, a discount that doesn't show.

The uninstall test

The clearest way to compare the two mechanisms is to imagine uninstalling the app.

With checkout-time calculation, there is nothing to clean up. The price fields were never touched, so removing the app removes the discounts and leaves your catalog exactly as it was. Your app subscription is handled by Shopify's billing system — when an app is uninstalled, Shopify automatically cancels the subscription.

With price rewriting, uninstall safety depends on the app's last cleanup job running correctly at the right moment. If it doesn't, nothing else will fix the prices — the app that knows the original values is gone. Some apps mitigate this with backups and restore routines, and the good ones take it seriously. But it remains a real code path that has to work, once, at exactly the right time.

Markets and multi-currency stores

If you sell through Shopify Markets, there's a second reason the mechanism matters. Markets lets you set prices per market — the same variant can have different prices in different countries. An app that writes to the base variant price doesn't naturally know about those market-specific price books, and a bulk price update can overwrite or desynchronize them.

An app that only calculates at checkout doesn't interact with any of this. Your per-market pricing stays configured exactly as you set it, and discounts are computed on top at checkout time.

The honest trade-offs of the checkout route

To be clear about what you give up with the Function-based approach:

• The product page shows the full price. If you want shoppers to see the deal while browsing, you need badges or widgets, which the app must provide (or you build them yourself).
• The discount only becomes tangible in the cart or at checkout, so the "gap between promise and proof" is wider than with a rewritten price tag.
• Functions have size and execution limits enforced by Shopify, which constrains extremely exotic discount logic.

None of these are hidden costs of Markdo specifically — they're properties of the mechanism. We think they're worth it, but you should weigh them with your own storefront in mind.

How to tell which mechanism an app uses, before you install

Four checks, none of which require asking a developer:

1. Read the listing for price vocabulary. Phrases like "bulk price editor", "scheduled price changes", "update prices automatically", or "compare-at price automation" indicate the price-writing mechanism.

2. Run a live test on a demo or trial. Activate a discount, then open a product page in an incognito window. If the displayed price on the product page changed without any widget or badge, prices are being rewritten.

3. Check the permissions conversation. Ask support one question: "Do you write to variant price fields?" A direct answer — either way — tells you what the app touches.

4. Ask what happens on uninstall. The answer should describe what the app does to your catalog when removed. "Nothing, because we never touch your prices" is a complete answer. A long restore procedure is a plan, not a guarantee.

Wrapping up

Neither mechanism is universally wrong. Price rewriting exists because some promotions genuinely need the whole storefront to show a new price, and well-built apps in that category manage the risks. But the mechanisms fail differently: one can fail into a broken catalog, the other into an invisible discount. Knowing which one an app uses — before you install it — is the difference between a support ticket and a corrupted Friday night.

That's the whole pitch, stated once: Markdo runs on Shopify Functions, never writes to your price fields, and pairs every rule with free storefront widgets so discounts stay visible before checkout. You can install it from the App Store and verify all of this on your own store.

If you want to go deeper on the architecture, we've written a full explainer on why Shopify Functions make discount apps faster, and a guide to what to do when you hit Shopify's 25 automatic discount limit.