See which apps use Extensions and Functions to power your checkout, online store, and more on Shopify

Something changes on checkout. A discount stacks when it should not. Shipping rates disappear. The storefront gets a little slower. And then you are sitting there thinking… which app is even doing this?

Shopify’s newer app visibility views fix a big part of that. You can now see which app features are actually active across your store, which ones are sitting there inactive, and which apps are collecting data through Pixels. It is the difference between guessing and knowing.

What this Shopify view actually tells you (and why it matters)

The core goal is simple : you can quickly see which installed apps are powering real parts of your store via Extensions and Functions.

Not marketing fluff like “installed” or “connected”. Actual, this app is touching checkout. This one is changing discounts. This one is injecting something into your theme. That kind of clarity.

Here is the plain language difference :

• Extensions are usually the visible surfaces. Think UI and placement.
• Checkout blocks. Customer account widgets. Theme app blocks. POS tiles.
• Functions are the behind the scenes logic. The rules engine stuff.
• Discount calculations, shipping rate logic, payment eligibility, and other checkout logic that can quietly change what customers see and pay.

Why you should care, beyond curiosity :

• Performance : extra storefront scripts and unused extensions can slow down key pages.
• Stability : fewer unknown touchpoints means fewer weird conflicts after updates.
• Debugging : when something breaks, you can trace the “who owns this” faster.
• Compliance and data access : pixels, permissions, and scopes matter a lot more now.
• Reducing mystery behavior : no more “I think it’s that app” troubleshooting.

And set your expectations correctly. This view is not just a list. You will be able to spot things like :

• active vs inactive features per app
• connection status (working vs needs attention)
• pixels and their data access mode
• function errors, before customers start complaining

Shopify Payments: Capital Remittance Now in All US States

If you have ever sold online, you already know the money part is never just “set it and forget it”.

EnovaiZakia

Where to find “Extensions and Functions” usage in your Shopify admin

In your Shopify admin, go to :

Settings > Apps

From there, select any installed app. Inside the app details, Shopify now shows a clearer breakdown of how that app connects into your store, including :

• Extensions : where the app is active (checkout, online store, customer accounts, POS)
• Functions : what logic it is running (discounts, shipping and delivery, payments, and other checkout related rules)
• Inactive Extensions and Functions : capabilities the app offers but you have not activated
• Pixels : whether the app is collecting customer data via pixels, plus connection status and data access mode

What you will typically see on these screens is basically a map : app name, the surfaces it touches, and indicators for feature status.

It also helps to cross check a few related areas when you are investigating something specific :

• Settings > Checkout (and any checkout customization areas you use)
• Discounts
• Shipping and delivery
• Payments
• Customer accounts settings
• POS channel settings (if you run retail)

This view is especially useful right after you do any of these :

• install a new app (even “just to test it”)
• switch or heavily edit a theme
• change checkout customizations
• prep for a big sale or launch
• do a performance or security audit (highly recommended, even if it is just you with a spreadsheet)

How to read the app “activity” details : active vs inactive features

This is the part that saves money and saves headaches.

Active app features means the app is currently doing something on a surface or in logic. Example :

• a checkout extension is enabled and visible in checkout
• a theme app block is enabled in your theme
• a discount function is actively calculating promotions

Inactive app features means the app can do something, but it is not currently activated. Example :

• you installed an app that offers an account page widget, but you never enabled it
• an app supports checkout upsells, but you have not turned that extension on
• the app includes shipping logic, but you are not using it

Common reasons features show as inactive (and this is normal) :

• you have not enabled it on that surface yet
• it is not compatible with your current setup (example, certain checkout or account configurations)
• permissions are missing, so Shopify will not let it run fully
• the app was uninstalled but artifacts remain in the theme or configuration
• settings are in draft vs published, so it is not live

How to use this to reduce bloat :

• find apps you installed “just in case”
• find features you turned on once and forgot about
• remove or disable what is not used, especially on the online store and checkout

One note though. Be careful and a little boring with change management. If you disable something, write it down somewhere :

• what you disabled
• where it was active
• why you disabled it
• how to roll it back if revenue drops

Future you will thank you. So will whoever has to troubleshoot during a weekend sale.

See which apps use Extensions across Shopify surfaces (what to check)

Extensions are where apps show up in real workflows. They are often visible, but not always obvious.

Here are the main surfaces to pay attention to and what “extensions” usually mean on each one.

Checkout

Checkout extensions can include :

• blocks and content (banners, trust messages, gift notes)
• upsells and add ons
• delivery options UI (how delivery choices display)
• extra fields and validation experiences

Checkout is high risk, high impact. Small clutter can reduce conversion. Conflicts can cause abandonment. So you want to be very clear which apps are touching it.

Customer accounts

Customer account extensions can include :

• order history enhancements
• returns and exchanges portals
• loyalty UI and points
• subscription management widgets
• support entry points

This is not always about conversion. It is about trust and support load. If customers cannot find returns, they email you. If the account area looks inconsistent, it feels sketchy.

POS

POS extensions can include :

• tiles and buttons for staff
• upsell prompts for in store carts
• customer lookup or loyalty workflows
• operational steps (like special fulfillment flows)

These affect operations. If something is slow or confusing at POS, it is not a “later” problem. Staff will work around it in messy ways.

What to record for each app while you review :

• which surface it touches (checkout, online store, accounts, POS)
• whether the extension is enabled
• whether it is still needed today

Shopify: Bundles Now Show on Draft Order Status Page

This is one of those updates that sounds tiny when you first hear it. Like, ok cool, bundles show up somewhere. Whatever.

EnovaiZakia

Checkout extensions : what "enabled" should mean before you trust it

"Enabled" on a screen is not the same as "working correctly on live checkout".

A quick practical checklist :

1. Confirm the extension is enabled in the correct checkout context (the one you actually use).
2. Verify it appears on a live checkout, not just in an editor preview.
3. Test with a real cart scenario (a couple products, a discount, shipping required). If possible, do a test order flow all the way to payment selection.

Common pitfalls to watch for :

• Duplicate widgets from two apps trying to do the same thing
• Branding conflicts across fonts, colors, tone, and spacing
• Slowed checkout from too many add-ons
• Unexpected eligibility logic, especially when discounts and shipping rules interact

A lightweight routine that is realistic : run one desktop checkout and one mobile checkout after any app install or update that touches checkout. Ten minutes, and you catch most issues early.

Online store extensions : avoid "invisible" bloat on your storefront

Online store extensions, especially theme app extensions, can be sneaky. Even if a widget is not visible on the page, the app may still be loading scripts or assets, which means slower pages and more potential points of failure.

Follow this simple process to clean things up :

1. Open theme customization.
2. Review all app blocks and app embeds.
3. Remove unused blocks and disable unused embeds.

After making changes, re-test these key pages :

• Homepage
• Product detail page
• Cart
• Any landing pages you run ads to

This ties directly to revenue. Unnecessary scripts can hurt speed, SEO, and even add-to-cart flow in subtle ways.

See which apps use Functions to power checkout logic (discounts, shipping, payments)

Functions are where apps stop being “a widget” and start being “the rule maker”.

Functions typically control things like :

• discount calculations
• shipping rate logic
• payment customizations and eligibility
• other backend rules tied to checkout outcomes

Why this matters is straightforward. Function logic can change totals, available shipping methods, or payment options. That means revenue, customer trust, and support tickets.

When you look at an app’s Functions, try mapping each one to a business rule :

• “Which app is deciding this?”
• “What happens if we disable it?”
• “Do we have a fallback?”

If you do nothing else, keep a simple logic inventory document. Literally a note with :

• Discounts owner : which app controls promos
• Shipping owner : which app controls rate logic
• Payments owner : which app hides or shows methods
• Fallback behavior : what should happen if the app is off

Discount Functions : identify what’s really applying promotions

Discount functions commonly power :

• tiered discounts
• bundles
• BOGO deals
• VIP pricing
• post purchase offers (depending on setup)

The big issue is overlap. You can easily end up with multiple apps trying to control the same discount logic. Then promos stack. Or they do not apply. Or the “wrong” discount wins.

Operational tip : align discount rules with your marketing calendar. When a promo ends, disable or remove the old promo logic so it does not accidentally come back later and stack with something new.

Shipping & delivery Functions : when rates or options look “wrong”

Shipping functions often handle :

• conditional shipping rates (by cart value, weight, region)
• local delivery logic
• carrier calculated rules and modifications
• cutoffs by date or region

Symptoms of misconfiguration usually look like :

• rates missing entirely
• unexpected free shipping
• wrong delivery estimates or options that should not be there

When this happens, do not immediately start changing carrier settings blindly. Go back to the Functions list and identify which app is responsible for shipping logic first. Otherwise you can fix the wrong thing and make it worse.

Payments Functions : understand why payment methods appear/disappear

Payments functions can do things like :

• hide payment methods by cart total
• hide methods by region
• hide methods by customer tag (VIP vs first time)
• add risk based rules

The risk is obvious. If a customer gets to checkout and their preferred payment method disappears, they might just leave.

Do a controlled test when payment logic changes :

• test different cart totals
• test different shipping locations (even just by changing address)
• if possible, test different customer states (logged in vs guest, tagged vs not)

Shopify: Track Non‑Sellable Inventory (Easy Setup)

Inventory in Shopify usually feels pretty straightforward. You receive stock, it shows up as available, customers buy it, it goes down. Done.

EnovaiZakia

Pixels and app data collection : understand what customer data apps can access

Pixels in Shopify are how apps and marketing tools collect event data. Things like page views, add to cart, checkout steps, purchases.

Apps request pixel access for reasons like :

• ads attribution
• analytics
• personalization
• conversion tracking

In the app details, you can now see pixel related info including :

• whether the app has pixel access
• connection status
• data access mode at a high level (basically, what kind of access and handling applies)

What to look for per app :

• does it still need pixel access for your current marketing stack
• what events it is reading
• whether you have duplicates (two tools firing the same purchase event)

Practical recommendation : remove unused pixels. It reduces data exposure and improves signal quality. Duplicate event firing can mess up attribution and reporting, and then you are making decisions on bad numbers. Which is the worst.

Permissions and connection status : audit apps without breaking your store

Permissions are the other half of the story.

In Shopify, app permissions define what apps can read and write, including orders, customers, products, fulfillment, analytics, and sometimes checkout or settings depending on the app.

Connection status matters too. If an app shows as connected vs needs attention, treat that as an early warning sign. "Needs attention" often means something is out of sync. Permissions changed, scopes changed, setup incomplete, or a feature is failing quietly.

When should you do a permissions update review?

• The app requests new access (scope changes).
• You have new compliance requirements.
• You are tightening access before a big season or after an incident.

Safe auditing mindset

• Remove the highest risk access you do not need.
• Do not break critical workflows like fulfillment or support tools.
• Keep notes on why an app needs certain permissions so you are not re-learning it later.

How to troubleshoot and resolve Function errors before customers notice

Function errors usually mean one of a few things : misconfiguration inside the app, incompatible store settings, missing dependencies, or conflicts between apps that both try to control the same thing.

A simple triage flow that works in real life

1. Identify the failing Function — which app and which function type.
2. Confirm where it is used : discounts, shipping, or payments.
3. Reproduce it in a test scenario using a cart that should trigger the rule.
4. Check recent changes, including app updates, theme edits, checkout customization changes, and discount or shipping setting changes.
5. If revenue is at risk, temporarily disable or roll back while you investigate.

Treat function errors like revenue-impacting incidents. Because they are. A discount error can kill conversion. A shipping error can stop checkout. A payments error can literally block purchases.

Also, assign ownership per Function or app — even if it is just "marketing owns discounts app" and "ops owns shipping app". Without ownership, fixes stall and everyone points at everyone else.

A practical "app stack" review workflow (monthly or before big launches)

You do not need a huge audit process. You need a repeatable one.

Here is a simple checklist you can run monthly, or before major launches :

1. List all installed apps.
2. For each app, note which surfaces it touches : checkout, online store, customer accounts, and POS.
3. Mark extensions as enabled or disabled.
4. Map Functions to business rules : identify which app owns discounts, which owns shipping logic, which owns payment visibility rules, and what the fallback is if an app is disabled.
5. Review pixels and data access. Remove duplicates and remove unused tracking.
6. Confirm permissions. Remove access you do not need and keep only what is required for core workflows.

When to run it

• Before BFCM
• Before major theme changes
• Before checkout changes
• Before introducing new discount or shipping logic
• After installing a few new apps in a short period (this happens more than people admit)

What you get out of it

• Fewer conflicts
• Faster storefront and checkout
• Cleaner analytics
• Reduced risk from unused permissions and forgotten tracking

Document decisions as you go. What you kept, what you disabled, and why. Otherwise six months from now, you will stare at an enabled extension and think, "Is this important… or just leftover?"

Conclusion

Shopify finally gives merchants a clearer way to answer the questions that actually matter : which apps are active, where they are active, what logic they control, and what data they can access.

If you get in the habit of checking Settings > Apps, then opening individual apps to review Extensions, Functions, inactive features, and Pixels, you stop running your store on assumptions. You start running it on a clean map.

That usually means fewer surprises at checkout, fewer support tickets, and a lighter app stack that does what you intended. Not what it accidentally ended up doing.

FAQs (Frequently Asked Questions)