Shopify App Conflict Checklist: Diagnose Theme, Cart and Script Issues

Shopify App Conflict Checklist: Diagnose Theme, Cart and Script Issues

A Shopify app conflict occurs when an app, theme customization, custom script or another integration attempts to control the same storefront feature, event or data workflow.

Common signs include duplicate widgets, broken cart behaviour, missing product options, app blocks that do not appear, repeated tracking events and pages that become slower after an app or theme change.

The safest way to diagnose the issue is to reproduce the problem, review recent changes and isolate one dependency at a time in a controlled environment.

This guide explains how to identify the likely cause, test it safely and validate the full customer journey before publishing any changes.

Quick Shopify App Conflict Checklist

Use this checklist before uninstalling apps or deleting theme code:

  • Record the exact affected page and customer action

  • Confirm the expected and actual result

  • Test the issue on another device or browser

  • Review recently installed or updated apps

  • Check recent theme, template and script changes

  • Duplicate the active theme before testing theme-level changes

  • Review app blocks on the affected template

  • Review active app embeds

  • Identify which app or code controls the affected feature

  • Disable one suspected dependency at a time

  • Repeat the same customer journey after every change

  • Review relevant browser-console and network errors

  • Retest connected cart, product and tracking workflows

  • Document the confirmed cause and resolution

  • Validate the storefront before publishing changes

Do not disable several apps or delete multiple code references at once. When several variables change together, it becomes difficult to identify the actual cause.

What Is a Shopify App Conflict?

A Shopify app conflict is a technical or functional problem caused by an app interacting incorrectly with another app, the active theme, custom code, Shopify data or an external platform.

A conflict does not necessarily mean that an app is defective. The problem may occur because two tools are trying to control the same feature, the theme no longer provides the structure an app expects or a connected workflow is receiving incomplete or inconsistent data.

Common examples include:

  • Two apps modifying the same product form

  • A cart app conflicting with theme cart logic

  • Duplicate review, chat or promotional widgets

  • An app block added to the wrong template

  • An app embed and custom script providing the same feature

  • Theme updates changing markup used by an app

  • Leftover code from an uninstalled app

  • Multiple tracking tools sending the same event

  • ERP, supplier or inventory apps updating the same records

The visible app is not always the source of the problem. The issue may begin elsewhere in the connected workflow.

Common Signs of Conflicting Shopify Apps

Duplicate Widgets or Storefront Elements

Customers may see two review sections, multiple chat buttons, overlapping pop-ups or repeated promotional messages.

This can happen when:

  • Two apps provide the same function

  • The theme already contains a similar feature

  • Both an app block and app embed are active

  • Previous app code remains in the theme

  • A widget is loaded through both an app and custom script

Start by identifying which tool owns each visible element.

Add-to-Cart or Cart Drawer Problems

A cart-related conflict may cause:

  • The add-to-cart button to stop responding

  • A product to be added twice

  • The cart drawer to remain closed

  • Cart quantities to update incorrectly

  • Product options to disappear

  • Discounts to stop applying

  • Subscription or bundle selections to be removed

Cart behaviour may involve the theme, bundle apps, subscription tools, upsell apps, product-option apps, discount logic and analytics events.

Test the complete cart journey rather than checking only the button.

Product Options Stop Updating

Product-option, personalization, bundle and subscription apps often depend on specific templates, product data or storefront events.

Problems may appear when:

  • A new product template is assigned

  • An app block is missing

  • Variant markup changes

  • Product data is incomplete

  • Custom JavaScript replaces an app-controlled value

  • Two apps modify the same product form

Compare the affected product with another product using the same template.

App Blocks Are Missing

A missing app block may indicate that:

  • It was added to a different product template

  • The affected section does not support app blocks

  • The block exists only in a duplicate theme

  • The active theme is different from the theme being edited

  • A theme update replaced a customized section

  • Visibility settings are hiding the block

Confirm the template, active theme and section before reinstalling the app.

App Embeds Are Not Working

App embeds commonly support:

  • Chat widgets

  • Consent banners

  • Analytics tools

  • Tracking pixels

  • Search tools

  • Product badges

  • Pop-ups

  • Floating storefront elements

An embed may fail because it is inactive, duplicated, loaded on the wrong pages, blocked by consent settings or dependent on another script.

Review the App embeds panel and test one suspected embed at a time.

Mobile Layouts Break

An app may work correctly on desktop but overlap buttons, navigation or product information on mobile.

Typical causes include:

  • Fixed-position widgets

  • App-generated CSS

  • Multiple floating buttons

  • Large pop-ups

  • Conflicting responsive breakpoints

  • App blocks inside narrow theme sections

  • Elements using unusually high stacking values

Test the affected feature at several mobile widths, not only one device.

Tracking Events Fire More Than Once

Duplicate tracking may occur when the same event is configured through:

  • Shopify customer events

  • An app pixel

  • Google Tag Manager

  • Theme code

  • A marketing app

  • A custom script

Review which platform is responsible for each event before removing tracking code.

Storefront Performance Declines

An app conflict may not fully break the page. It may instead make page interactions slower.

Potential causes include:

  • Multiple third-party scripts

  • Duplicate widgets

  • App embeds loading on every page

  • Repeated API requests

  • Script errors triggering retries

  • Several apps waiting for the same storefront event

  • Large external resources

Measure the same page before and after changing one suspected dependency.

Why Shopify App Conflicts Happen

Several Tools Control the Same Store Function

The same function may be controlled by more than one app or code source.

Store function Possible controllers
Add to cart Theme, bundle app, product-options app
Cart drawer Theme, upsell app, subscription app
Product reviews Review app, theme section
Discounts Shopify settings, discount app, Shopify Functions
Product options Theme, personalization app, bundle app
Tracking Shopify pixel, app pixel, Tag Manager, custom script
Inventory Shopify, supplier app, ERP
Shipping messages Theme, shipping app, cart app

Any function with several possible controllers deserves closer investigation.

App Blocks Are Added to Different Templates

Shopify stores can use separate templates for different products, pages and collections.

An app block added to one product template may not appear on another. A section may also support app blocks in one area but not in another.

Check:

  • Which template is assigned

  • Whether the block exists in that template

  • Whether the correct theme is being edited

  • Whether the block is active

  • Whether section settings affect visibility

App Embeds and Custom Scripts Overlap

A store may load the same or similar functionality through:

  • An app embed

  • Theme code

  • Google Tag Manager

  • A custom script

  • Another app

  • A native theme feature

Review both the App embeds panel and custom theme code before deciding which tool is responsible.

Theme Updates Change Required Markup

Apps may depend on specific:

  • Product forms

  • Cart elements

  • CSS classes

  • Section IDs

  • Liquid objects

  • JavaScript events

  • Variant selectors

A theme update can change these elements even when the visible design remains similar.

Critical app-dependent journeys should be tested before publishing a new theme version.

Old App Code Remains After Uninstalling

Some apps leave code, assets, metafields or template references behind after removal.

Possible leftovers include:

  • Liquid snippets

  • Script references

  • CSS files

  • Theme-layout includes

  • App-specific assets

  • Tracking code

  • App-created metafields

  • Modified templates

  • External webhook configurations

Only remove code that has been positively identified as belonging to the uninstalled app. When ownership is unclear, compare theme versions or consult the app developer before deletion.

External Systems Update the Same Data

Shopify apps connected to an ERP, CRM, supplier, warehouse or fulfilment platform may update:

  • Inventory

  • Prices

  • SKUs

  • Order status

  • Customer data

  • Fulfilment locations

  • Tracking numbers

A visible storefront issue may therefore begin with conflicting data ownership rather than theme code.

Shopify App Conflict Decision Tree

Use this sequence to narrow the likely cause.

Does the issue appear only in the current theme?

Yes:
Review theme customization, app blocks, template assignments and app-theme compatibility.

No:
Review global app settings, app embeds, store data and external systems.

Did the issue begin after an app or theme change?

Yes:
Test that change first in a duplicate theme or controlled environment.

No:
Check product-specific data, external systems and recently modified workflows.

Does disabling one app block remove the symptom?

Yes:
The issue likely involves the block, its template or another feature in the same section.

No:
Review app embeds, custom scripts, data dependencies and backend app behaviour.

Does the problem affect only selected products?

Yes:
Check product templates, variants, metafields, metaobjects and app-specific product conditions.

No:
Review global theme logic, app embeds and scripts.

Does the issue occur only after adding a product to the cart?

Yes:
Review theme cart logic, bundles, subscriptions, upsells, product options and discount tools.

No:
Continue testing the affected page or workflow.

Does the problem continue after the suspected app is disabled?

Yes:
The cause may be theme code, leftover app code, another app or connected data.

No:
Confirm the result by restoring the app and repeating the same test.

Merchant-Safe Checks vs Developer-Level Checks

Some checks can be performed safely through Shopify admin. Others require technical experience.

Merchant-safe checks Developer-level checks
Record the exact symptom Inspect JavaScript errors and stack traces
Review recently installed apps Review event listeners and script order
Check app blocks Compare network requests and responses
Check app embeds Trace cart and product-form events
Confirm the active template Review API or webhook errors
Preview a duplicate theme Modify Liquid, JavaScript or CSS
Review app permissions Identify residual app code
Contact app support Test external data and integration logic

Avoid editing unfamiliar code on the live theme.

Step-by-Step Diagnostic Workflow

Step 1: Define the Exact Symptom

Avoid starting with “the app is broken.”

Record:

  • Affected page URL

  • Product or collection

  • Device

  • Browser

  • Customer action

  • Expected result

  • Actual result

  • Error message

  • Screenshot or screen recording

  • Date the issue began

A precise description makes the problem easier to reproduce.

Step 2: Reproduce the Problem

Repeat the same journey using the same product, variant, device and customer state.

Determine whether the issue happens:

  • Every time

  • Only on mobile

  • Only on selected products

  • Only for logged-in customers

  • Only in one market

  • Only when two features are active

  • Only after a page refresh

Do not proceed until the symptom can be reproduced consistently or its conditions are understood.

Step 3: Review Recent Changes

Check whether the problem began after:

  • Installing or updating an app

  • Activating an app embed

  • Adding an app block

  • Publishing a new theme

  • Editing Liquid or JavaScript

  • Changing a template

  • Adding tracking

  • Modifying discounts

  • Connecting an external system

  • Updating shipping or fulfilment settings

Start with the most recent relevant change.

Step 4: Duplicate the Active Theme

Create a duplicate of the current theme before testing theme-level changes.

Use it to review:

  • App blocks

  • App embeds

  • Templates

  • Liquid changes

  • Cart behaviour

  • Responsive layouts

Important Limitation

A duplicate theme is not a complete staging environment.

It can help isolate theme-level behaviour, but it may still use the same:

  • Products and customers

  • App backend settings

  • Webhooks

  • Inventory data

  • External integrations

  • Fulfilment locations

  • Tracking configurations

Do not assume that every test inside a duplicate theme is isolated from live business systems.

Step 5: Review App Blocks and Template Assignments

Open the affected template in the theme editor.

Check for:

  • Duplicate app blocks

  • Missing app blocks

  • Blocks added to another template

  • Blocks placed in the wrong section

  • Visibility conditions

  • Unsupported section structure

  • Old blocks from previous apps

Confirm that the affected product or page actually uses that template.

Step 6: Review App Embeds

List the active app embeds in the theme.

Pay particular attention to:

  • Chat tools

  • Tracking apps

  • Consent tools

  • Product badges

  • Search apps

  • Pop-ups

  • Accessibility overlays

  • Floating widgets

Temporarily disable one suspected embed in the duplicate theme and repeat the same test.

Step 7: Map Feature Ownership

Document which app, theme component or system controls the affected functionality.

Feature Current controller Possible overlap
Product options App A Theme product form
Cart drawer Theme Upsell app
Subscriptions App B Product-options app
Reviews App C Theme review section
Tracking App D Tag Manager
Inventory ERP Supplier app

This identifies where two systems may be competing.

Step 8: Change One Dependency at a Time

For every test:

  1. Change one app block, embed or script

  2. Save the change

  3. Reload the preview

  4. Repeat the same customer journey

  5. Record the outcome

  6. Restore the original setting when necessary

  7. Test the next suspected dependency

Changing one variable at a time makes the result easier to verify.

Step 9: Review Technical Errors

A Shopify developer may inspect:

  • JavaScript errors

  • Failed network requests

  • Duplicate event listeners

  • Blocked resources

  • API failures

  • Missing variables

  • Repeated requests

  • Script-loading order

  • External service errors

A browser-console error is not automatically the cause. Confirm whether it appears during the affected journey and whether removing the suspected dependency changes the result.

Step 10: Test the Complete Connected Journey

Fixing the visible element is not enough.

Retest:

  • Variant selection

  • Product options

  • Add to cart

  • Cart drawer

  • Quantity updates

  • Bundles

  • Subscriptions

  • Discounts

  • Shipping messages

  • Analytics events

  • Mobile layouts

  • Order creation

  • Customer notifications

A change that fixes one component may break another connected feature.

Step 11: Document the Confirmed Cause

Record:

  • Original symptom

  • Affected pages

  • Confirmed cause

  • Apps or code involved

  • Test performed

  • Fix applied

  • Journeys retested

  • Remaining risks

  • Responsible owner

This record will reduce investigation time if the issue returns after a future app or theme update.

Illustrative Diagnostic Example

The following scenario is illustrative and should not be presented as an EcomHeroes client case unless replaced with verified project information.

Symptom

A mobile cart drawer opens and immediately closes after a product is added.

Recent Change

An upsell app was activated on product pages.

Initial Assumption

The theme’s cart drawer JavaScript was broken.

Diagnostic Test

The app embed was disabled in a duplicate theme. The same product, variant and add-to-cart journey was repeated.

Likely Finding

The theme and upsell app were both responding to the same cart-update event.

Resolution Approach

Assign the cart-opening behaviour to one controller and disable or modify the duplicate behaviour.

Validation

Retest:

  • Standard products

  • Products with upsells

  • Quantity updates

  • Mobile and desktop cart drawers

  • Discounts

  • Analytics events

Replace this example with a real anonymized case when one is approved for publication.

App Conflict or Theme Problem?

Use this table as a starting point rather than a final diagnosis.

Signal More likely app-related More likely theme-related
Issue began after installing an app Yes Possible
Duplicate widget appears Yes Less likely
Disabling an app embed fixes the issue Yes No
Problem occurs only on one template Possible Yes
Issue began after a theme update Possible Yes
A custom section stops rendering Possible Yes
Problem continues after the app is disabled Less likely Yes
Cart event fires twice Yes Possible
Incorrect data comes from an external system Possible Less likely

Many problems involve both the theme and the app. An app may function correctly while the theme no longer provides the markup or event the app expects.

What to Check Before Uninstalling an App

Uninstalling an app should not be the first troubleshooting step.

Before removing it, confirm:

  • Which storefront features depend on it

  • Whether it manages inventory or fulfilment

  • Whether it creates a Shopify location

  • Which automations rely on it

  • Whether it connects to an external platform

  • Whether app data should be exported

  • Whether billing must be cancelled separately

  • Whether manual theme cleanup is required

  • Whether another app will replace its responsibilities

  • Whether its previous settings can be restored

Document the current configuration before removal.

How to Check for Leftover App Code

After an app is removed, review:

  • Theme snippets

  • Liquid render statements

  • Script references

  • App-specific assets

  • Custom CSS

  • App blocks

  • App embeds

  • Tracking pixels

  • Metafields and metaobjects

  • External webhooks

  • Template modifications

Use this safer cleanup process:

  1. Duplicate the current theme

  2. Review the app’s removal documentation

  3. Search for the app name and known code identifiers

  4. Compare affected files with an earlier or clean theme version

  5. Remove only positively identified references

  6. Preview the affected pages

  7. Retest connected customer journeys

  8. Publish only after validation

Do not remove unfamiliar code only because the file name looks old or unrelated.

Post-Fix Validation Checklist

Use this checklist after making any change.

Validation test Pass/Fail
Correct product price appears after variant selection
Product options remain selected
Add-to-cart runs once
Correct product and quantity enter the cart
Cart drawer opens and closes correctly
Cart quantities update correctly
Discounts calculate as expected
Bundle or subscription selections remain intact
Shipping messages display correctly
Widgets appear only once
Mobile elements do not overlap
Analytics events fire once
No relevant browser errors remain
Workflow works in the intended market
Merchant team can still manage the feature

 

How to Reduce Future App Conflicts

Assign One Owner Per Store Function

Avoid using several apps for the same function unless their responsibilities are clearly separated.

Maintain an App Responsibility Register

Document:

  • App purpose

  • Business owner

  • Technical owner

  • Affected pages

  • Store data accessed

  • External systems connected

  • Renewal date

  • Removal process

Test Theme Updates Before Publishing

Review all app-dependent product, cart and tracking journeys in a duplicate or development theme.

Remove Unused Apps Carefully

Unused apps may still affect scripts, data, billing, fulfilment locations or integrations.

Retest After Significant Changes

Repeat relevant checks after:

  • Theme updates

  • App installations

  • App removals

  • Product-template changes

  • Cart modifications

  • Tracking changes

  • Integration updates

For a wider schedule of recurring technical checks, link to the Shopify Store Maintenance Checklist.

When Is a Shopify Developer Needed?

Professional Shopify support may be appropriate when:

  • The issue affects the cart or purchase journey

  • Several apps control the same feature

  • Custom Liquid or JavaScript is involved

  • The problem appears only under specific product conditions

  • An ERP, CRM, supplier or external API is involved

  • Tracking events are duplicated or missing

  • App removal leaves code or data dependencies

  • The store team cannot reproduce the issue safely

  • The proposed fix affects several templates

  • The issue returns after app or theme updates

For custom theme code, app workflows and storefront functionality, explore Shopify Development Services.

For recurring monitoring, updates and technical checks, explore Shopify Maintenance Services.

Frequently Asked Questions

Can two Shopify apps conflict with each other?

Yes. Shopify apps can conflict when they control the same storefront element, cart event, product data, script or external workflow. Common symptoms include duplicate widgets, missing buttons, incorrect cart behaviour, repeated tracking events and slow page interactions.

Can a Shopify app break my theme?

An app can affect a theme through app blocks, app embeds, Liquid code, JavaScript or CSS. Problems can also appear when a theme update changes a template or storefront event that the app relies on.

Why is my Shopify app block not showing?

The app block may be missing from the active template, added to another theme or placed inside a section that does not support it. Confirm the assigned template, active theme, block visibility and section compatibility.

Why is my Shopify app embed not working?

The embed may be inactive, configured for another theme or page, blocked by consent settings or dependent on another script. Check the App embeds area and test the suspected embed in a controlled theme.

Does uninstalling a Shopify app remove all its code?

Not always. An app may leave theme snippets, scripts, assets, metafields or template changes behind. Remove only references that have been positively identified as belonging to the uninstalled app.

How do I find which Shopify app is causing a problem?

Reproduce the issue, review recent changes and disable one suspected app block, app embed or dependency at a time. Repeat the same journey and record the result after each controlled change.

Can too many Shopify apps slow down a store?

Several apps may load scripts, widgets and external requests on the same page. The actual effect depends on what each app loads, where it loads and whether another tool provides similar functionality.

Should I test Shopify app conflicts on my live theme?

Use a duplicate or development theme for theme-level testing whenever possible. Remember that a duplicate theme may still share app settings, products, inventory and external integrations with the live store.

Can an app conflict affect Shopify checkout?

An app conflict can affect the journey leading to checkout, including product options, cart data, subscriptions, discounts and shipping messages. The affected behaviour should be tested from product selection through order creation.

When should I contact the app developer?

Contact the app developer when the issue involves app-specific settings, stored data, permissions, billing, compatibility or removal instructions. Provide the affected URL, reproduction steps and details of the tests already completed.

Need Help Diagnosing a Shopify App Conflict?

Share the affected page, apps involved, recent changes and expected behaviour.

EcomHeroes can review the issue and recommend a fixed-scope investigation, custom Shopify development or an ongoing technical maintenance approach.

Explore Shopify Development Services

Back to blog