Shopify flips default for subscription discounts: what the appliesOnSubscription change means for developers and merchants

Table of Contents

1. Key Highlights:
2. Introduction
3. What changed — precise description and immediate effect
4. Why defaults matter: behavioral and operational impact
5. How Shopify evaluates discounts at checkout (quick primer)
6. Where this change applies: DiscountCodeAppInput and DiscountAutomaticAppInput
7. Practical examples: creating discounts with GraphQL (templates you can adapt)
8. Tests to run now — what developers should verify
9. Edge cases and pitfalls
10. Compatibility and API versioning — what “applies across all active API versions” means for you
11. Recommendations for app developers — explicitness, testing, and tooling
12. Recommendations for merchants and store teams
13. Integrations and third-party subscription platforms — what to watch for
14. Observability and detection strategies
15. Real-world scenarios and examples
16. Governance and change control checklist
17. How to handle legacy discounts already created (audit and remediation)
18. Troubleshooting unexpected behavior
19. Policy and business considerations
20. Long-term best practices to avoid surprises from default changes
21. Example implementation: a helper function pattern (pseudo-code)
22. Observations from the field: why Shopify could make this change
23. Final guidance: a concise action plan
24. FAQ

Key Highlights:

• Shopify changed the GraphQL Admin API default for appliesOnSubscription from false to true on DiscountCodeAppInput and DiscountAutomaticAppInput; no action required if your app explicitly sets the field.
• The change applies across all active API versions and does not alter how discounts are applied at checkout; review your discount logic and testing if you rely on implicit defaults.
• Best practice: explicitly set appliesOnSubscription and appliesOnOneTimePurchase in discount creation to make intent explicit, add tests, and monitor for unexpected discount behavior in stores with mixed subscription and one-time product lines.

Introduction

Shopify adjusted a subtle but meaningful default in its Admin GraphQL API on May 4, 2026: the appliesOnSubscription flag now defaults to true for two discount input types — DiscountCodeAppInput and DiscountAutomaticAppInput. The platform says this change does not affect how discounts are applied at checkout, and apps that already set the field explicitly will see no behavior change. Still, the default flip has implications for developers, merchant teams, and the ecosystems built on top of Shopify subscriptions.

This article explains exactly what changed, who should pay attention, and how to confirm that discount behavior matches your business intent. It includes technical examples, testing strategies, compatibility notes, and practical guidance for developers and merchants who create or rely on app-provisioned discounts — whether through discount codes or automatic discounts — in stores that sell subscriptions, one-time purchases, or both.

What changed — precise description and immediate effect

The GraphQL Admin API input types DiscountCodeAppInput and DiscountAutomaticAppInput accept a boolean field: appliesOnSubscription. Shopify changed the default value for that field from false to true. That means when an app creates or updates discounts via those input types and omits the appliesOnSubscription field entirely, the API will behave as if appliesOnSubscription is true.

Key points extracted from Shopify’s note:

• The change is a default value change only. If your application explicitly supplies appliesOnSubscription when creating or updating a discount, nothing changes.
• The appliesOnOneTimePurchase field already defaults to true; that default remains unchanged.
• The default change is applied across all active API versions.

Shopify’s assurance that "no action is required" applies to correctness of the API response: discounts will continue to be evaluated at checkout the same way Shopify has always evaluated them. Nevertheless, implicit defaults influence how newly created discounts behave when client code omits explicit values.

Why defaults matter: behavioral and operational impact

Default values in APIs shape real-world behavior when clients omit fields. Even when the marketplace asserts that checkout application is unchanged, default flips introduce risk in three common scenarios:

1. Legacy or minimal clients that rely on implicit defaults. Some clients omit optional flags, assuming platform defaults. Those clients now create discounts that apply to subscription line items where before they did not.
2. Automation or templating systems that generate discount inputs dynamically. Template engines or server-side libraries that produce discount payloads without explicitly setting appliesOnSubscription will inherit the new default.
3. Cross-system integrations where the discount decision is declared only once. For stores using external subscription platforms, a mismatch between the subscription engine’s expectations and the discount defaults can result in discounts appearing for subscription orders unexpectedly.

Operationally, the primary concern is unintended discount leakage onto subscription orders, which could translate into revenue erosion, incorrect unit economics for subscription SKUs, or unhappy stakeholders if discounts were supposed to be one-time only.

How Shopify evaluates discounts at checkout (quick primer)

Understanding the appliesOnSubscription flag requires a quick look at how Shopify evaluates discounts:

• Discounts operate at order/checkout level against order lines. For multi-line orders — containing both subscription items and one-time purchases — adding a discount that applies to subscription items means those lines become eligible for the discount.
• DiscountCodeAppInput is used to create discounts that customers apply via a code at checkout. DiscountAutomaticAppInput is used for discounts applied automatically when criteria are met.
• Shopify supports separate flags to express whether a discount targets subscription purchases, one-time purchases, or both. Earlier, appliesOnOneTimePurchase defaulted to true while appliesOnSubscription defaulted to false; now both default to true when omitted.
• The final discount calculation at checkout still follows Shopify’s combination rules (stacking, priorities, and exclusions) and any custom logic that subscription apps or Shopify Functions might implement.

This change does not alter the underlying evaluation engine, only the default signal an API client sends (or omits) when creating a discount.

Where this change applies: DiscountCodeAppInput and DiscountAutomaticAppInput

Both of these input types accept an appliesOnSubscription boolean:

• DiscountCodeAppInput: used for discount codes created via apps (code-based promotions).
• DiscountAutomaticAppInput: used for automatically applied discounts created via apps.

When those inputs omit appliesOnSubscription, the Admin GraphQL API will now assume a value of true. The appliesOnOneTimePurchase field already defaults to true.

Developers should audit any code paths that construct those input objects without explicitly setting both appliesOnSubscription and appliesOnOneTimePurchase.

Practical examples: creating discounts with GraphQL (templates you can adapt)

Below are illustrative GraphQL mutation examples showing how discount creation can be expressed. They include examples that rely on implicit defaults and explicit-field examples that make intent unambiguous.

Note: the mutation shape may vary with API version; treat the payload structures as representative. Confirm exact field names and return payloads against the Admin GraphQL schema for the API version you call.

1. Example — creating a discount code that relies on implicit defaults (will now apply to subscriptions)

GraphQL mutation skeleton (client variable usage):

mutation discountCodeAppCreate($discount: DiscountCodeAppInput!) { discountCodeAppCreate(discount: $discount) { userErrors { field message } discount { id code appliesOnSubscription appliesOnOneTimePurchase } } }

Example variables:

{ "discount": { "title": "10-PCT-FALL", "code": "10PCTFALL", "value": { "percentage": 10.0 }, "appliesOnOneTimePurchase": true // Notice appliesOnSubscription is omitted — previously default false, now true } }

Because appliesOnSubscription is omitted, Shopify treats it as true.

2. Example — explicit intent: make discount code apply only to one-time purchases

Explicitly set both flags to ensure behavior is unambiguous:

{ "discount": { "title": "10-PCT-ONE-TIME", "code": "10PT1", "value": { "percentage": 10.0 }, "appliesOnOneTimePurchase": true, "appliesOnSubscription": false } }

3. Example — automatic discount that applies to subscriptions and one-time items (explicit)

{ "discount": { "title": "SUMMER-SAVER", "startsAt": "2026-06-01T00:00:00Z", "endsAt": "2026-06-30T23:59:59Z", "value": { "percentage": 15.0 }, "appliesOnSubscription": true, "appliesOnOneTimePurchase": true } }

The practical takeaway: provide explicit values for both appliesOnSubscription and appliesOnOneTimePurchase whenever your application cares which purchase types should receive the discount.

Tests to run now — what developers should verify

Even though Shopify states no action required, run these checks to be safe:

1. Audit code bases:
   • Search for any construction of DiscountCodeAppInput or DiscountAutomaticAppInput that does not set appliesOnSubscription explicitly.
   • Look at templated payloads, JSON serializers, and clients that build payloads on the fly.
2. Test discount creation flows:
   • For any discount intended to exclude subscriptions, create it in a development store with appliesOnSubscription false and verify subscription line items do not receive the discount.
   • Create the same discount while omitting appliesOnSubscription to confirm the new default behavior (it will apply on subscription) and compare results.
3. Verify third-party integration behavior:
   • If you use a subscription provider or middleware that creates discounts on your behalf, confirm what values those integrations send. Many integrations rely on Shopify’s Admin APIs and might omit optional fields.
4. Run end-to-end checkout tests:
   • Build test orders containing mixed line items (subscription + one-time). Confirm the discount allocation matches expected behavior.
   • Test both code-based and automatic discounts.
5. Check logs and analytics:
   • After deploying any code changes, monitor discount usage reports and subscription order margins. A spike in discount usage on subscription orders could indicate unintended application.
6. Add unit and integration tests:
   • Add tests to assert that any discount creation or update payload includes both appliesOnSubscription and appliesOnOneTimePurchase set explicitly according to business rules.

Edge cases and pitfalls

Several nuanced situations deserve attention:

1. Mixed carts with subscription and one-time items:
   • Merchants may expect a discount to apply only to a one-time starter product. If the discount inadvertently applies to subscription items, the margin on subscription SKUs may be wrong.
2. Scheduled or multi-phase discounts:
   • If promotional pipelines automatically create discounts for multiple channels or audiences, implicit defaults can create inconsistent targeting across different promotions.
3. Bundles and composite SKUs:
   • Bundled products that include subscription components might be treated as subscription-eligible at checkout. Confirm discount eligibility evaluation in these cases.
4. Discount stacking and priorities:
   • Shopify supports multiple discounts under specific rules. A discount that now applies to subscription items interacts with other discounts and pricing rules, potentially changing the final price unexpectedly.
5. Subscription apps and webhooks:
   • Subscription providers that calculate charges outside Shopify’s checkout flow may interpret discounts differently. Validate both the checkout-time discount application and post-checkout processing.
6. Internationalization and variant-level pricing:
   • Discounts that are targeted at certain SKUs by variant IDs encounter the same default behavior. Ensure that variant-level discount conditions are properly configured when subscriptions exist for particular variants.

Compatibility and API versioning — what “applies across all active API versions” means for you

Shopify models API evolution through versions. When a change is described as applying across all active API versions, it means Shopify updated the default behavior in the service layer that enforces the schema, so calls to those input types on any supported version will observe the new default. For developers this implies:

• Calls that omit appliesOnSubscription will receive the new implicit true behavior regardless of the API version selected among currently supported ones.
• If you pin older API versions in your integration, verify how your SDKs or generated clients serialize optional fields; some client libraries may include explicit nulls or default values that differ from Shopify’s service-side default.
• When planning long-lived automation, prefer explicit field settings over relying on platform defaults to remove ambiguity across future platform changes.

Consult Shopify’s API versioning policy and the Admin API changelog for details of supported versions and lifecycle timelines if you need to align release windows with version updates.

Recommendations for app developers — explicitness, testing, and tooling

Adopt these concrete practices to avoid surprises.

1. Explicitly set both appliesOnSubscription and appliesOnOneTimePurchase.
   • Make both booleans mandatory in your internal data models for discount creation APIs. This prevents implicit assumptions and documents intent clearly.
2. Centralize discount-building logic.
   • Maintain a single library or helper function to construct discount payloads. That reduces duplication and makes future changes to default rules easier to apply.
3. Add defensive tests.
   • Unit tests: ensure the discount payload includes both flags set correctly.
   • Integration tests: create a discount and run a checkout flow that includes subscription line items.
   • Regression/Smoke tests: run periodic checks to capture unexpected changes in discount behavior.
4. Version control and release notes.
   • When you change your app’s behavior or UI regarding subscription discounts, log the change and include it in release notes so merchant administrators understand the rationale.
5. Telemetry and audit logs.
   • Log discount creation payloads and store responses (masking sensitive data). Capture who created the discount, by which app, and the appliesOnSubscription/appliesOnOneTimePurchase settings.
6. Provide merchant-facing controls.
   • In your app UI, show an explicit toggle for subscription vs one-time applicability. When the admin omits settings, display a warning that the platform now defaults to enabling subscription application.
7. Error handling and user errors.
   • Make sure your error-handling surfaces any API userErrors returned by discount creation calls. If the API rejects a discount update for policy reasons, surface the message to the merchant clearly.
8. Educate internal teams.
   • Customer support and account management should be briefed about the change so they can advise merchants with subscription models.

Recommendations for merchants and store teams

Merchants typically do not interact directly with raw GraphQL inputs, but they will feel the effects. Follow these steps:

1. Inventory active discounts.
   • Export a list of active discount codes and automatic discounts. Identify discounts that should not apply to subscriptions.
2. Review discount targeting and eligibility.
   • For each discount, confirm whether it should apply to subscription products or only to one-time purchases. Use Shopify’s discounts admin UI or app dashboards to inspect settings.
3. Update any app-managed discounts.
   • If an app manages discounts on your behalf, confirm that it explicitly sets appliesOnSubscription according to your promotional goals.
4. Communicate with subscription providers.
   • If your subscriptions are managed by a third-party app, verify how that app creates discounts and whether it sends explicit flags.
5. Monitor metrics post-change.
   • Track average order value, subscription revenue, and margins. Look for changes correlating with discount usage by line type.
6. Test buying flows:
   • Run sample checkouts that mix subscription and non-subscription items. Ensure expected discounts apply.
7. Train customer support.
   • Provide scripts to handle customer questions when a discount does or does not apply to subscription renewals.

Integrations and third-party subscription platforms — what to watch for

Many stores rely on subscription platforms that interact with Shopify’s Admin APIs. If your subscription provider:

• Generates discounts via the Admin GraphQL API: Verify whether it sets appliesOnSubscription explicitly. If not, clarify the new default behavior with the provider and request an explicit flag if necessary.
• Interposes billing calculations outside Shopify: Confirm the provider’s reconciliation logic when a discount applies to subscription items at checkout.
• Relies on Shopify’s discount reporting: Evaluate how discounts applied to subscription orders are represented in provider dashboards and reconciliation exports.

Gap analysis between subscription provider behavior and Shopify’s defaults can help prevent double discounts or mismatched discount treatments.

Observability and detection strategies

Catch unintended discount applications quickly with monitoring approaches that work across organizations of any size:

1. Alerts on discount usage:
   • Set up alerts when a discount begins to be applied to subscription SKUs that historically did not receive discounts.
2. Diff reports:
   • Produce daily diffs of discounts applied to subscription orders and compare against baseline periods.
3. Post-purchase reconciliation:
   • Reconcile checkout totals and subscription invoices to detect discrepancies caused by misapplied discounts.
4. Audit trails:
   • When your app creates or updates discounts, write an immutable audit record containing the exact payload sent to Shopify plus the response. That record aids troubleshooting.
5. Analytics segmentation:
   • In analytics tools, segment orders by subscription vs one-time, and monitor conversion and margin metrics separately.
6. Shadow testing:
   • For new discount creation logic, perform shadow-run tests that simulate discount creation without persisting the discount, then compare expected vs actual behavior in a sandbox environment.

Real-world scenarios and examples

Below are three illustrative scenarios that show the possible impacts of the default change and how to handle them.

Scenario 1: Merchant runs a “first-order” discount intended only for one-time purchases

• Intent: 20% off first purchase; not intended for subscription starter packs or subscription renewals.
• Risk: If the app creating the discount omits appliesOnSubscription, the discount now applies to subscription checkouts as well.
• Mitigation: Update discount creation to set appliesOnSubscription false explicitly; run mixed-checkout tests and confirm subscription SKUs not discounted.

Scenario 2: Subscription-based product with a free trial converted into a discount code offer

• Intent: Provide an incentive code that applies for the initial subscription order but not recurring charges.
• Complexity: Shopify’s discount applications at checkout may apply to the initial subscription line; if the intent is to apply one-time discount only to the first order, ensure that discount application logic and subscription provider behavior are aligned.
• Mitigation: Explicitly set appliesOnSubscription true if you want subscription checkouts to receive the discount and make sure your subscription provider reconciles the discounted trial correctly.

Scenario 3: Automatic cross-sell discount for non-subscription add-ons

• Intent: Automatically apply 5% off any non-subscription add-on when included with a subscription.
• Risk: The automatic discount may now apply to the subscription product itself if the automatic discount condition and default flags aren’t explicit.
• Mitigation: In the automatic discount input, set appliesOnSubscription false and configure eligibility conditions to include only one-time SKUs.

Governance and change control checklist

Use this checklist to manage risk when updating apps or store discount configurations.

For developers:

• Audit code paths for omission of appliesOnSubscription
• Update discount-building helpers to require explicit flags
• Add unit tests asserting flags are present
• Perform integration tests on dev stores with subscription line items
• Deploy telemetry to capture discount creation payloads and responses

For merchants:

• Export all active discounts and document desired applicability
• Engage app vendors to confirm explicit flag usage
• Run mixed-line checkout testing in a development store
• Monitor discount usage on subscription orders for 2–4 weeks after changes

Cross-team:

• Document change in internal knowledge bases
• Communicate to customer support and account managers
• Prepare rollback procedures for any automated discount creation systems

How to handle legacy discounts already created (audit and remediation)

For existing discounts created before the change, determine intent and remediate if necessary:

1. Audit: List all discounts created by apps or automation in the past 12 months and inspect their appliesOnSubscription/appliesOnOneTimePurchase settings where available.
2. Test representative samples in a development store or checkout sandbox:

• If the discount was created without an explicit appliesOnSubscription and now behaves differently than intended, update the discount to set appliesOnSubscription to the intended value.

3. For high-impact discounts (e.g., global promotions or high-volume discounts), perform controlled updates and monitor key metrics post-change.
4. If your automation cannot update past discounts (some discount types or third-party app-managed discounts may be immutable), create a replacement discount with explicit flags and retire the old one after a short transition period.

Troubleshooting unexpected behavior

If you detect discounts applying differently than intended, use this troubleshooting flow:

1. Confirm discount definition:
   • Retrieve the discount using the Admin GraphQL API and inspect appliesOnSubscription and appliesOnOneTimePurchase values. Does the record explicitly set them or are they implicit?
2. Reproduce the checkout:
   • Create a test checkout that mirrors the problematic order: identical SKUs, subscription flags, customer tags, and discount code.
3. Check for overlapping discounts:
   • Identify automatic discounts or other discount codes that could interact and influence final pricing.
4. Review third-party providers:
   • Ask your subscription provider or discount manager whether they created or updated the discount and what values were sent.
5. Analyze logs:
   • Look back at the payload that created the discount. If your app logs the JSON payload, confirm whether appliesOnSubscription was omitted.
6. Remediate:
   • Update the discount if possible. If it cannot be updated, create a new discount with explicit parameters and sunset the old one.
7. Communicate:
   • Notify affected stakeholders and customers if refunds or adjustments are necessary due to incorrect discount applications.

Policy and business considerations

Discounts applied to subscription products interact with broader business policies:

• Revenue recognition: Discounts on subscriptions can affect recurring revenue reporting. Ensure finance teams are aware of any promotional discounts on subscription SKUs.
• Lifetime value calculations: Applying discounts to subscription items alters average revenue per user (ARPU) and LTV metrics.
• Churn and retention: Discounts on the initial subscription might change retention behavior; conversely, discounts on renewals reduce net revenue over the customer lifetime.
• Compliance and terms: Some markets require clear disclosure when recurring charges are discounted or when promotional pricing affects future renewal pricing.

Cross-functional coordination between engineering, finance, marketing, and legal is necessary when discount defaults change.

Long-term best practices to avoid surprises from default changes

1. Favor explicitness:
   • Always set booleans explicitly in API calls. Never rely on platform defaults for business-critical flags.
2. Treat API releases as contract changes:
   • Even changes that seem non-functional can affect behavior. Run scheduled audits of critical API interactions.
3. Automate discovery:
   • Implement a daily job that fetches discount metadata and verifies compliance with expected settings.
4. Maintain shadow environments:
   • Simulate changes in a sandbox where the production semantics are mirrored but cannot affect live customers.
5. Keep a runbook:
   • Document steps for how to handle misapplied discounts, including how to create replacement discounts and issue refunds if needed.

Example implementation: a helper function pattern (pseudo-code)

Below is a conceptual pattern for a discount payload builder. It shows the principle of explicitness and centralization:

function buildDiscountPayload(options) { return { title: options.title || "", code: options.code || null, value: options.value, appliesOnSubscription: options.appliesOnSubscription === true, appliesOnOneTimePurchase: options.appliesOnOneTimePurchase === true, startsAt: options.startsAt || null, endsAt: options.endsAt || null, // other fields... }; }

Always pass both appliesOnSubscription and appliesOnOneTimePurchase explicitly when calling the GraphQL mutation, even if the desired value is true.

Observations from the field: why Shopify could make this change

While Shopify’s notice focused on default semantics, the change aligns with broader merchant expectations in several ways:

• Many merchants run promotions that are intended to apply broadly, across subscription and non-subscription purchases. A default that favors inclusivity reduces surprises for merchants who expect a discount to cover all purchase types.
• Consistent defaults (both appliesOnOneTimePurchase and appliesOnSubscription defaulting to true when omitted) remove asymmetry that previously required more deliberate configuration.
• From an API ergonomics standpoint, setting both defaults to true reduces friction for common promotional use cases while placing responsibility on developers to explicitly opt-out when required.

Regardless of the motivation, the practical impact comes down to ensuring intent is encoded explicitly in API interactions.

Final guidance: a concise action plan

• Search codebases and templates for any discount creation calls that omit appliesOnSubscription.
• Update discount construction code to set both appliesOnSubscription and appliesOnOneTimePurchase explicitly.
• Run unit and integration tests covering mixed checkouts.
• Audit third-party subscription and discount integrations for implicit field omissions.
• Add monitoring and alerts for discount usage on subscription SKUs.
• Document the change in internal release notes and train support teams.

Taking these steps protects revenue and ensures discounts behave predictably.

FAQ

Q: Does this change affect existing discounts already created in stores? A: Existing discounts retain the settings they were created with. The default change only affects cases where the appliesOnSubscription field was omitted during discount creation or update going forward; Shopify treats such omissions as true. If a discount explicitly set appliesOnSubscription to false when created, that explicit setting remains.

Q: Will discounts now apply to subscription renewals automatically? A: The flag appliesOnSubscription determines whether a discount is eligible for subscription line items at checkout. Subscription renewals follow subscription provider and Shopify billing rules. If a discount is configured to apply to subscription items at checkout, it affects the initial purchase that creates the subscription. Recurring billing discounts or future renewals may be controlled elsewhere by subscription providers and billing logic. Confirm treatment of discounts for renewals with your subscription app.

Q: My app already sets appliesOnSubscription; do I need to change anything? A: No functional change occurs for apps that explicitly set the field. Best practice remains to continue setting the flag explicitly to document intent.

Q: How do I check whether a discount was created with appliesOnSubscription set explicitly or omitted? A: Retrieve the discount object via the Admin GraphQL API. The object will indicate the values for appliesOnSubscription and appliesOnOneTimePurchase. If your app logs the original payload when creating the discount, that log can tell you whether the field was omitted. If the object shows appliesOnSubscription true but you didn’t set it explicitly, that likely indicates the default was applied.

Q: Could this change cause refunds or financial impacts? A: Unintended discounts applied to subscription items can reduce revenue and may require refunds or adjustments in rare cases. Monitor discount usage and margins; if you see unexpected behavior, remediate by updating discount settings, issuing adjustments, and communicating with affected customers.

Q: Are there any Shopify API versioning steps I should take? A: The change is applied across active API versions. You do not need to migrate API versions to see the new default. However, review your versioning strategy and ensure your clients and SDKs serialize optional fields in a manner consistent with your intent. Pinning to an older version does not prevent service-layer default behavior from applying.

Q: How should third-party subscription providers be handled? A: Contact your subscription provider to confirm how it constructs discounts. Ask whether it sets appliesOnSubscription explicitly and whether it handles discount application for recurring billing. If necessary, request an update to set explicit flags.

Q: What are the best monitoring metrics to watch after this change? A: Watch discount usage counts segmented by subscription vs one-time orders, changes in average order value for subscription orders, number of transactions receiving a specific discount code, and margin per subscription SKU. Set alerts for anomalies in discount-applied conversions on subscription SKUs.

Q: Can I automate detection of discounts created without explicit flags? A: Yes. Use a scheduled job to fetch discount metadata and check whether appliesOnSubscription and appliesOnOneTimePurchase are explicitly set (where the API exposes whether a value was set explicitly). If explicit information isn’t available, correlate logs of discount creation payloads with the discount record to detect omissions.

Q: If I want a discount to apply only to subscriptions, what should I do? A: Explicitly set appliesOnSubscription to true and appliesOnOneTimePurchase to false when creating the discount. Add tests that verify the discount is applied only to subscription line items in mixed checkouts.

Q: Does this change affect discount eligibility conditions (collections, product IDs, customer segments)? A: No. This change only modifies the default boolean value for appliesOnSubscription on the two input types named. Eligibility conditions you specify remain in effect. However, because more discounts may now apply to subscription line items by default, evaluate eligibility settings if they interact with subscription product sets.

Q: Where can I find further reference material? A: Consult the Shopify Admin GraphQL reference pages for DiscountCodeAppInput and DiscountAutomaticAppInput and review the changelog and API versioning documentation to understand current support windows and migrations.

If you need a tailored checklist, code review guidance, or assistance designing tests specific to your store or app, I can provide a step-by-step plan and sample test cases for your environment.