Every app installed in a Shopify store promises higher sales, better UX, or process automation. From a technical perspective, however, most frontend extensions are additional scripts that must be downloaded and executed by the customer’s browser. An excess of third-party tools is one of the most common causes of declining site performance. The problem is compounded by the fact that many apps leave so-called ghost code in the theme after uninstallation-code fragments that still generate requests to servers that no longer exist. Understanding how to identify these loads and safely clean Liquid files is essential for maintaining strong Core Web Vitals and optimal conversion. (Verification: Many Shopify apps leave code after uninstallation that generates requests to non-existent servers.)
Why do Shopify apps slow down your store?
Most Shopify apps work by injecting JavaScript into the head section or before the closing body tag in theme.liquid. These scripts are often loaded synchronously, which means the browser must pause rendering of the visible page until external code is downloaded and executed. This is called render-blocking. Even when an app uses async or defer loading, it still burdens the browser’s main thread, which directly affects Total Blocking Time (TBT) and Interaction to Next Paint (INP). Understanding the mechanisms that load the theme is key to diagnosing why a Shopify store runs slowly and which elements need optimization. Third-party scripts compete for resources with critical store elements such as interactive menus or add-to-cart buttons, which on weaker mobile connections can lead to site abandonment.
The difference between synchronous and asynchronous scripts lies in how the browser treats the file while building the DOM. Synchronous scripts completely stop page display. Async scripts allow background download but execute immediately after download, which can also interrupt rendering. The safest approach for performance is the defer attribute, which runs the script only after the HTML structure is fully parsed. Unfortunately, many apps force synchronous loading so their features (e.g., pop-ups or widgets) appear as quickly as possible-at the cost of overall load speed.
How to check an app’s impact on load speed (diagnostic tools)
Performance diagnosis should not rely solely on a single PageSpeed Insights score. To realistically assess the impact of specific tools, you need raw data showing how many requests each app generates and how long they take to process.
Network tab analysis in Chrome DevTools
The most precise way to detect unnecessary scripts is Chrome DevTools. After opening the store, right-click and choose Inspect, then go to the Network tab. Refresh the page with logging enabled and filter results by JS. The Initiator column is critical-hovering over it shows which domain triggered a given script. If you see dozens of requests to domains such as s3.amazonaws.com or app vendor servers you no longer use, that indicates unnecessary load. Pay attention to the Time column and Waterfall view, which visualize when the browser waits on external servers. This analysis helps isolate scripts that generate the most long tasks-operations lasting over 50 ms-which hurt interface responsiveness.
Shopify Theme Inspector for Chrome and flame graphs
The official Shopify Theme Inspector extension analyzes server-side performance-the time needed to generate Liquid code. (Verification: Shopify Theme Inspector analyzes Liquid rendering time on the server.) It produces flame graphs showing which sections and snippets load longest. If an app injects code directly into Liquid files, Theme Inspector points to the exact code fragment delaying page rendering. Long horizontal blocks on the chart indicate bottlenecks. Often a single “related products” or “reviews” app causes more delay than the rest of the theme combined. Interpreting chart colors helps quickly locate the heaviest loops (e.g., for loops) that scan the entire product catalog on every page refresh.
Ghost code - why code remains after removing an app
Ghost code results from the specifics of older Shopify APIs. Many apps had to physically modify theme files, appending their scripts or render tags. When the store owner removes an app in the admin, Shopify revokes its access, but it cannot always automatically clean changes in .liquid files. Dead references remain in the code. The customer’s browser still tries to fetch resources from app servers that no longer exist or no longer recognize the store, resulting in 404 errors in the console and unnecessary load-time extension. Effective Shopify store speed optimization requires not only removing unused tools but, above all, thoroughly cleaning leftover code.
Examples include tags in the head section that reference external .js or .css files. Even if a file is empty or returns an error, the browser must open a connection (DNS lookup, TCP handshake, TLS negotiation), which costs valuable milliseconds. On uninstall, Shopify’s API loses access to theme files, so app developers have no technical way to clean up if their code was inserted manually or by an install script directly into Liquid structure.
Removing unnecessary code from the theme - step-by-step
When manually cleaning code, exercise maximum caution. Every change in Liquid files can affect store functionality. Before modifying Liquid files, a comprehensive Shopify technical audit can precisely identify all elements burdening the browser’s processor.
Where to look for leftovers in .liquid files
- theme.liquid: Check the head section for script tags containing developer names or unknown external domains.
- Snippets: Review the Snippets folder for files whose names start with popular app prefixes (e.g.,
bold-,yotpo-,klaviyo-). - product.liquid and cart.liquid: Look for
{% render 'app-name' %}or{% include 'app-name' %}tags. - Global search: Use CTRL+F in the Shopify code editor, entering the removed app name or terms like
asyncanddeferwhere they are not systematically justified.
Safely testing changes in Preview mode
Never edit code on the live theme. First create a backup (Actions > Duplicate). Work only on the copy. After removing a suspicious code fragment, use Preview to thoroughly test the purchase path: from the homepage through the product page to the cart. Also open the developer console (F12 > Console) and check for red Uncaught ReferenceError messages that might indicate the removed code was tied to another working feature. Verification should also include analytics and tracking pixels, which are often linked to external scripts.
Online Store 2.0 and App Blocks - the performance safety standard
Online Store 2.0 architecture significantly changed how apps integrate with the theme. With Theme App Extensions, app developers no longer need to modify Liquid files directly. Instead they create App Blocks that can be added and removed through the visual theme editor. The biggest advantage is that when a block is removed or an app is uninstalled, all related code disappears automatically and completely. No ghost code is created and file structure stays clean. When choosing new tools in the Shopify App Store, look for the “Online Store 2.0” label or App Blocks support, which simplifies long-term technical maintenance.
Comparing the old code-injection model with the new standard shows a clear benefit in resource control. In the OS 2.0 model, app scripts load only on pages where the app block actually appears. In older solutions, a returns-handling script was often loaded on every page, including the homepage, even when completely unnecessary. Moving to App Blocks is one of the most effective ways to limit technical debt in e-commerce.
Optimization strategy: When to replace an app with custom code
Many popular e-commerce features can be implemented without installing heavy third-party apps. Often one app exists only to show a simple info bar or size chart, yet loads libraries hundreds of kilobytes in size. TCO (Total Cost of Ownership) analysis often shows that a one-time custom implementation costs less than the sum of monthly subscriptions and conversion losses from a slower store.
Features worth implementing natively
- Size charts and product tabs - achievable with Metafields and simple Liquid/CSS.
- Countdown timers - a lightweight JS script written for a specific theme is faster than a ready-made app.
- Simple free-shipping messages - native Shopify sections can display this dynamically without external scripts.
- Trust icons and payment logos - static images embedded directly in section code generate no extra HTTP requests.
- Simple newsletter signup forms - email marketing integration can often run through Shopify’s native form without extra widgets.
FAQ
Does every installed app slow down a Shopify store?
Not every one, but most frontend apps add JavaScript that must be downloaded and executed by the browser. Apps that work only in the admin (backend) usually do not affect page load speed for customers.
How do I check whether ghost code remains after removing an app?
The simplest way is to inspect theme.liquid and the Snippets folder in the Shopify code editor. If render or include tags with that app’s name are still visible after uninstallation, unnecessary code remains in the theme.
Do Speed Booster-type apps actually speed up the store?
They often work by preloading pages, which can improve perceived speed but adds another script to execute. In many cases, manually removing unnecessary apps delivers better results than installing another app to optimize them.
Where in Chrome DevTools should I look for scripts that slow the store?
Go to the Network tab, refresh the page, and filter by JS. The Time column shows load duration, and Initiator indicates whether the script comes from Shopify directly or from an app vendor’s external domain.
Can removing app code break the store’s appearance?
Yes, if you remove code responsible for page structure or CSS styles. That is why backing up the theme before every edit and testing in Preview before publishing is essential.
What are App Blocks in Online Store 2.0?
A modern way to integrate apps with Shopify that lets you add functionality to the theme without manual Liquid editing. When such a block is removed, all related code is automatically removed from the page.
Bibliography
- Shopify Dev Docs - Theme App Extensions - Explanation of Online Store 2.0 and App Blocks.
- Google Chrome DevTools - Network Analysis - Guide to analyzing external scripts and the Initiator column.