)
Backing up, versioning and keeping a Shopify theme updatable: what counts when changing agency
What the theme contains and what it does not
A Shopify theme contains layout, templates, sections, blocks, stylesheets, scripts, translations of theme texts and all settings from the theme editor, including the arrangement of sections on the home, product and collection pages.
The theme does not contain products, collections, pages, blog posts, menus, metaobjects, customers, orders or any admin settings. Checkout is not part of the theme either; it is designed through the checkout editor and apps. Backing up the theme therefore backs up the look, not the store.
Three ways to back up a theme
Duplicate in the store. Under Online Store > Themes, click the three dots next to the theme and choose Duplicate. The copy sits in the theme library. Name it with a date and reason. A store can hold up to 20 themes. A duplicate protects against editing mistakes, but not against losing the store or the access.
Download the theme file. In the same menu, choose Download theme file. Shopify sends a ZIP file to the email address of the signed-in user. It is a backup outside Shopify, but a snapshot without history. Watch whose address it goes to: if the old agency triggers the download, the backup ends up with them.
Connect to GitHub. This is the route we recommend for every store that is worked on regularly. More below.
Versioning with the Shopify GitHub integration
Shopify can connect a theme directly to a branch in a GitHub repository, via Online Store > Themes > Add theme > Connect from GitHub. Synchronisation runs both ways:
Every change in the connected branch updates the theme in the store.
Every change in the admin, whether in the code editor, the theme editor or by an app, is automatically committed back to the branch by Shopify. Since 2026 the commit also names the person who last edited the theme.
This makes every theme change traceable: when, what, by whom. If something is wrong after a change, exactly that state can be restored instead of resetting the whole theme to an old copy.
Two points that matter in practice:
The repository belongs in your GitHub organisation, not the agency's. Shopify itself recommends using GitHub organisations rather than personal accounts for the integration. If the repository is with the agency, it takes the whole history with it when it leaves.
The integration expects the standard folder structure of a Shopify theme. If the agency works with a build process, meaning source code that is compiled first, a separate branch with the finished theme is needed. In that case, ask explicitly for the source code, not just the finished theme.
The underestimated problem: themes that no longer receive updates
Themes from the Shopify Theme Store regularly receive updates from their developer: new features, bug fixes, adaptations to new Shopify features. Shopify shows under the theme's version number whether an update is available. However, Theme Store updates are only available for themes installed from there, not for uploaded themes.
The problem starts when theme files are edited directly. Changes made only in the theme editor, such as sections, blocks and settings, carry over in an update. Direct code changes, by contrast, only carry over if the developer did not change the same file. If both collide, Shopify adds the new version to the theme library without those customisations and reports which files are affected. Ignoring that means losing features when publishing.
Many agencies work around this by simply not updating any more. We regularly see the result in takeovers: a theme two or three years behind the current version, without improvements in load time, accessibility and new Shopify features.
How a theme stays updatable
The difference lies in how customisations are built:
Custom features in their own files. Create new sections, blocks and snippets as separate files instead of rewriting the developer's original files. They are left untouched by an update.
Change original files only where there is no other way, and document every change. With the GitHub integration this happens automatically.
App features through app extensions. Modern apps integrate through app blocks and app embeds and do not alter theme code. Older apps wrote code directly into the theme, which stays behind after uninstalling.
Apply updates on a copy, resolve collisions deliberately, test on the copy and only then publish.
Check licence and developer
Themes bought from the Theme Store are licensed to the store they were bought for. A theme file uploaded to another store is not licensed there and receives no updates. Themes bought outside the Theme Store only receive updates from their developer. Older themes from before Online Store 2.0 no longer receive updates through the admin; for those, moving to a current theme usually pays off.
The right order when changing agency
Inventory: which theme, which version, how far behind the current state, bought from the Theme Store or uploaded?
Back up: duplicate and download the live theme while the old agency still has access. The file goes to an address of your company.
Take over the repository: if one exists, it is transferred to your GitHub organisation, with history and, if available, source code. If none exists, the new agency connects the theme to a new repository in your organisation. From then on, every change is versioned.
Record customisations: a comparison with the developer's original version shows which files were changed. This is the basis for making the theme updatable again.
Find old app code and remove it after checking. More in Shopify apps and subscriptions when changing agency.
Work only on copies: the new agency never edits the live theme directly.
Remove the old agency's access, see Shopify staff account and collaborator access.
What to ask your agency
Is our theme connected to a repository, and do we own it?
Which version is our theme, and when was a developer update last applied?
Which original files were changed, and is that documented?
Is there code from apps in the theme that are no longer installed?
Do you work directly in the live theme or on a copy?
How we do it at arboro
On the first day of a takeover we back up the live theme, connect it to a repository in your GitHub organisation and compare it with the developer's original version. That tells us how far it lags behind and what is needed to make it updatable again. We build new features as separate sections and blocks, develop changes on copies and only publish them after your approval. arboro.PULSE then monitors the store continuously, from load times to structured data. How we develop Shopify themes is described on Shopware & Shopify development, and how we check a theme's technical SEO on Shopify SEO. More about the process on Switch your Shopify agency.
Frequently asked questions
No. Products, collections, pages, blog posts, menus, metaobjects and customers live in the store, not in the theme. Checkout is not part of the theme either.
Either it was uploaded rather than installed from the Theme Store, or its code is customised so heavily that updates collide with the customisations, and then it often stops being updated at all. A comparison with the original version shows what is needed to make it updatable again.
Every theme change is automatically saved as a commit, including changes in the theme editor, with date and editor. Errors can be reverted precisely, and the history stays with you if the repository is in your GitHub organisation.
No. Theme Store themes are licensed to the store they were bought for. An uploaded copy in another store is not licensed and receives no updates.
Your theme backed up, versioned and updatable again
We back up your theme on day one, connect it to a repository in your organisation and show what is needed for it to receive updates again.
)