In theory, a Shopware update is three commands long. Bump the version in composer.json, run composer update, run bin/console system:update:finish. Done. On 21 November 2026 we ran through exactly that on two fresh throwaway shops: once as a small update inside the 6.7 line (6.7.13.1 → 6.7.16.1), and once as a jump across the major version (6.6.10.32 → 6.7.16.1). Both updates succeeded in the end. The pure compute time was under 15 seconds each.
The interesting part is what happened in between. Between swapping the code and finishing the migrations, our shop returned HTTP 500, even with maintenance mode switched on. Maintenance mode itself only took effect after we cleared the cache. A plugin that was explicitly only released up to 6.7.13 simply kept running after the update. And on the jump from 6.6 to 6.7, Composer aborted with an error that is fixed by a command almost no quick guide mentions.
This article walks through the full procedure with every measurement: backup, update, maintenance window, rollback, and the major jump. No customer data, no production systems. Everything ran in test instances that were deleted afterwards.
Shopware update: the short version
| measured | |
|---|---|
| Small update | 6.7.13.1 → 6.7.16.1 |
composer update (18 packages) | 6.9 s |
system:update:finish | 3.0 s, 146 MB RAM |
| Migrations | 848 → 894 (+46) |
| Tables | 252 → 256 |
| Storefront between code and migration | HTTP 500 |
| Database dump beforehand | 2.0 MB (0.2 MB gzipped), 0.39 s |
| Full rollback incl. dump import | 11.8 s |
| Major update | 6.6.10.32 → 6.7.16.1 |
composer update -W | 63 package operations, 7.2 s, aborted without recipe update |
| Migrations, major | 722 → 919 (+197), 230 → 256 tables |
system:update:finish, major | 4.7 s |
composer create-project shopware/production and system:install --basic-setup, APP_ENV=prod. HTTP measurements with curl against PHP’s built-in web server. The absolute times apply to empty test shops without products; what matters is the order of states (when 500, when 503, when 200).
Which Shopware version am I running?
Before you plan a Shopware update, you need to know where you stand. The command line is fastest:
php bin/console --version
# Shopware 6.7.13.1 (env: prod, debug: false)
In the Administration, the version is shown at the bottom left of the menu or under Settings → System → Shopware update. Composer also tells you which packages are lagging:
composer outdated "shopware/*" -D
# shopware/administration 6.7.13.1 ! 6.7.16.1
# shopware/core 6.7.13.1 ! 6.7.16.1
# shopware/elasticsearch 6.7.13.1 ! 6.7.16.1
# shopware/storefront 6.7.13.1 ! 6.7.16.1
One detail our measurement made visible: a plain composer update updates nothing. The composer.json of a Shopware project pins shopware/core to an exact version ("shopware/core": "v6.7.13.1"). A dry run therefore reported “Nothing to modify in lock file” even though three newer versions were available. That is intentional. Updates do not happen by accident.
How often are Shopware updates released?
According to Packagist, 25 versions of the 6.7 line and 22 patch versions for 6.6.10 were released in 2026 up to 21 November. Shopware ships a minor release with new features roughly once a month (e.g. 6.7.15.0), with patches for bug and security fixes in between (6.7.15.1). The four-part number reads like this:
| Digit | Example | Meaning |
|---|---|---|
| 6 | 6.7.16.1 | Product generation, practically never changes |
| 7 | 6.7.16.1 | Major version, breaking changes for plugins and themes |
| 16 | 6.7.16.1 | Minor release, new features, backwards compatible |
| 1 | 6.7.16.1 | Patch, bug and security fixes |
So the digit Shopware calls “major” is the second one. Going from 6.6 to 6.7 is a big update; going from 6.7.13 to 6.7.16 is a small one, even with three numbers in between.
Does Shopware 6.6 still get updates?
Yes. Version 6.6.10.32 was released on 18 November 2026. According to its release policy, Shopware maintains the current line and the last version of the previous line. If you are on 6.6, first move to the newest patch within 6.6 and plan the jump to 6.7 as a separate project. That is exactly what we did in the second part of this article.
Before the update: a backup you can actually restore

A Shopware update changes two things at once: the code (Composer, vendor/) and the database (migrations). A backup has to cover both, or it is not a backup.
Database: A dump with --single-transaction does not lock InnoDB tables and can therefore run against a live shop.
mariadb-dump --single-transaction -u shopuser -p shopware > before-update.sql
gzip -k before-update.sql
Our empty test shop produced a 2.0 MB dump in 0.39 seconds, 0.2 MB gzipped. A real shop with an order history is orders of magnitude larger. Measure it once on your own system and you know the minimum length of your maintenance window. Dump variants, encryption, and restore tests are covered in MySQL Backup.
Code: The cleanest approach is a Git repository over the project. The shipped .gitignore already excludes vendor/, .env.local, public/media, and public/theme. What gets committed is composer.json, composer.lock, symfony.lock, configuration, and your own plugins. The code state of a version is then exactly one commit.
git add -A && git commit -m "State before update to 6.7.16.1"
Media and environment: public/media, files/, and .env.local are not in Git. They belong in your normal file backup. How to organise that so a single failure does not take everything with it is explained in the 3-2-1 backup strategy.
The most important rule: a backup whose restore you have never practised is a hope. We actually ran the rollback below and timed it.
The small update: 6.7.13.1 to 6.7.16.1
Starting point: a freshly installed shop on 6.7.13.1, 848 migrations, 252 tables, storefront and admin returning HTTP 200. Plus a tiny home-made plugin GmTestPin whose composer.json deliberately only allows "shopware/core": "~6.7.13.0". It simulates an extension the vendor has not yet released for newer versions.
Step 1: raise the version in Composer
composer require "shopware/core:6.7.16.1" --no-update
composer update "shopware/*" --with-all-dependencies --no-scripts
--no-update only writes composer.json without resolving right away. The second command updates all Shopware packages and lets Composer move the dependencies along. Our result: 18 package operations in 6.9 seconds, including, besides the four Shopware packages, twig/twig 3.28 → 3.29 and symfony/mcp-bundle 0.11 → 0.15. Composer finished with “No security vulnerability advisories found”.
The Git diff afterwards showed three changed files: composer.json, composer.lock, and public/.htaccess. The .htaccess change was just a missing newline at the end of the file. Sounds trivial, but it is exactly the kind of change that causes a merge conflict or a silent overwrite on a server with a customised .htaccess. Read git diff after every update.
Step 2: the dangerous moment
Now new code is on disk, but the database is still on the old schema. We requested the storefront in exactly that state:
storefront-midway 500 1017
<title>An Error Occurred: Internal Server Error
The log had the reason:
CRITICAL: Uncaught PHP Exception Doctrine\DBAL\Exception\InvalidFieldNameException:
"Unknown column 'language.translation_auto_update' in 'SELECT'"
The new code expects a column that only one of the 46 new migrations creates. That is not a bug, it is the normal consequence of code and schema briefly not matching. But it means: every visitor who arrives at this moment sees an error page. How long the moment lasts depends only on how fast you get from step 1 to step 3.
system:update:prepare does not change that either. We ran it and measured again: still HTTP 500. The command fires preparation events (plugins can hook into them); it does not migrate anything.
Step 3: finish the update
php bin/console system:update:finish
This command runs the migrations, updates plugins, copies the assets of all bundles to public/bundles, and clears the cache. For us: 3.0 seconds, peak 146 MB RAM. Afterwards the database held 894 migrations and 256 tables.
storefront-after 200 0.56 s 78873 bytes
then: 0.008 s, 0.007 s, 0.006 s
admin 200
Shopware 6.7.16.1 (env: prod, debug: false)
The first request after the update took 0.56 seconds because the container and templates are recompiled. The following ones took 6 to 8 milliseconds. If you click through the home page and a few categories yourself right after updating, you take that cold start off your real customers’ hands.
The Shop Studio video is from 2022 and shows the Administration route. The UI has changed since, but the principle (backup, check plugin compatibility, update, test) is the same.The plugin that should not have kept running
After the update to 6.7.16.1, plugin:list still reported our test plugin as installed and active, even though its composer.json only allows ~6.7.13.0. No notice, no warning in the update output. Only when we deactivated it and tried to activate it again did the check kick in:
Could not activate plugin, got 1 failure(s).
Required plugin/package "shopware/core ~6.7.13.0" does not match installed version == 6.7.16.1.
In practice that means: a running plugin is not checked for compatibility during the update. Whether it works with the new version, you find out when it breaks, or when you have to reactivate it one day and suddenly cannot. Our test plugin was empty, so it kept working. A real plugin that overrides a changed core class would have produced an error page instead.
The consequence: check every plugin individually before updating. In the Shopware Store, each extension lists the versions it is released for. For your own plugins, look at their composer.json. How to build plugins that survive updates is shown in Shopware Plugin Development.
Maintenance mode: what it does and what it does not

Shopware has a maintenance mode per sales channel. You can switch it on in the Administration or on the console:
php bin/console sales-channel:maintenance:enable --all
php bin/console sales-channel:maintenance:disable --all
This is where our second finding came in. Right after maintenance:enable we requested the home page: HTTP 200, the full shop page, 78,031 bytes. Byte for byte the same response as before. The page came from the HTTP cache, which knew nothing about maintenance mode. Only after cache:clear did the shop behave as expected:
/ → 307 redirect to /maintenance?redirectTo=frontend.home.page
/maintenance → 503 Service Unavailable
/admin → 200 (Administration stays reachable)
/api/... → 401 without token (API stays active)
The 503 on the maintenance page is correct. It tells search engines the outage is temporary and keeps the page from being cached as content. A short 503 is harmless for Google; a 200 saying “we’ll be right back” is a bad signal. More on Shopware and search engines in Shopware SEO.
To let specific visitors (yourself, your agency) into the shop anyway, add their IP addresses as an exception on the sales channel in the Administration.
Does maintenance mode help during the update?
That was the real question. We ran the update a second time, this time with maintenance mode on and a loop requesting the home page and the maintenance page every 0.5 seconds. Condensed, the log looked like this:
Count Home page /maintenance Phase
4 307 503 maintenance on, old code
2 500 500 composer install swaps vendor/
12 307 503 new code, finish running, cache cleared
7 200 302 maintenance off, update done
Two requests hit the moment Composer swapped the vendor/ directory. Both returned HTTP 500, including the maintenance page. Around that there was a gap of roughly three seconds in which one request only came back after a long wait. Maintenance mode is part of Shopware. When Shopware itself is not runnable, it cannot serve anything.
After the code swap, i.e. while system:update:finish was running, maintenance mode held reliably: we saw no further 500s. The error from step 2 (missing column) was invisible to visitors.
What follows from this:
- Switch maintenance mode on and then run
cache:clear, otherwise the cache keeps serving the normal shop. - Maintenance mode does not protect the code swap itself. If you want zero error pages, you need a maintenance page in front of PHP, in the web server (nginx, Apache, Caddy) or the load balancer. A simple way: a static HTML file that nginx serves with a 503 while a switch file exists.
- The cleanest way is not to change code in the live directory at all: build the new release in its own folder, run
composer installthere, then switch a symlink. That is how deployment tools like Deployer work. Shopware also offers theshopware/deployment-helperpackage for this. We did not test it for this article.
Rollback: how fast can you get back?

Say something important no longer works after the update. We measured two ways back.
Rolling back only the code
git checkout HEAD~1 -- composer.json composer.lock symfony.lock
composer install --no-scripts
Afterwards 6.7.13.1 was running again, against a database with the 894 migrations of 6.7.16.1. The storefront still returned HTTP 200, before and after clearing the cache. There is a reason: Shopware migrations are written so that old code keeps working on a newer schema. New columns do not bother old code; it simply does not query them. Columns and tables are only removed in a later step that Shopware calls “destructive migrations”.
That is a quick emergency exit, but not a state to stay in. Old data indexes, plugin states, and new records no longer reliably fit together. For an emergency on a Friday night, it is enough.
Rolling back code and database
git checkout HEAD~1 -- composer.json composer.lock symfony.lock
composer install --no-scripts
mariadb -e "DROP DATABASE shopware; CREATE DATABASE shopware"
mariadb shopware < before-update.sql
php bin/console cache:clear
php bin/console assets:install
Total time from the first command to HTTP 200: 11.8 seconds, then back to exactly 848 migrations. In a real shop the dump import dominates. A gigabyte of SQL takes a few minutes depending on the server, not seconds.
The price: everything that happened in the database between backup and rollback is gone. New orders, new customer accounts, stock changes. That is exactly why maintenance mode makes sense before the backup, not after. If no order can come in during the window, none can be lost in a rollback.
The big update: 6.6 to 6.7

A major update is a different league. Between 6.6 and 6.7, Shopware moved Doctrine DBAL from version 3 to 4, completed the switch of the Administration to Vue 3, reworked the cache, and removed plugin interfaces that had been marked deprecated before. All of that is in UPGRADE-6.7.md in the Shopware repository. If you have your own plugins or theme, you need to read it. For merchants without custom extensions, the more important question is whether all purchased plugins are released for 6.7.
Our test: a fresh shop on 6.6.10.32 (722 migrations, 230 tables), no plugins.
The first attempt fails
composer require "shopware/core:6.7.16.1" --no-update
composer update "shopware/*"
Composer refused with a long list. The key line:
shopware/administration[v6.7.8.0, ..., v6.7.16.1] require doctrine/dbal ~4.4.0
-> found doctrine/dbal[4.4.0, ..., 4.4.5] but the package is fixed to 3.10.7 (lock file version)
Without --with-all-dependencies, Composer may only touch the named packages, and DBAL 3 does not fit Shopware 6.7. So with -W:
composer update "shopware/*" -W
This time 63 package operations in 7.2 seconds: DBAL 3.10.7 → 4.4.5, four packages removed (doctrine/event-manager, lcobucci/clock, padaliyajay/php-autoprefixer, tecnickcom/tcpdf), new ones added. And then the abort at the end:
Script assets:install returned with error code 255
[critical] Uncaught Exception: You have requested a non-existent parameter "shopware.service_registry.url".
The code was already 6.7, but the project’s configuration was still 6.6. config/bundles.php was missing a bundle that did not exist in 6.6. From this point on, not even bin/console would start.
The fix: update the Symfony recipes
The shopware/production project template uses Symfony Flex. Files like bundles.php, public/index.php, .env, and the build scripts come from so-called recipes. Composer updates the packages, but not the files that were once copied into the project from a recipe. You have to trigger that explicitly:
composer recipes # shows: shopware/core (update available)
git add -A && git commit -m "composer to 6.7" # recipes require a clean working tree
composer recipes:update shopware/core
composer recipes:update shopware/administration
composer recipes:update shopware/storefront
Composer only agreed to update the recipes after all changes were committed (“Please commit or stash them and try again”). Then it reported “Recipe updated” three times. The result in the diff: 10 files, among them
config/bundles.php: a new lineShopware\Core\Service\Service::class, exactly the missing bundle,public/index.php: 10 lines changed,bin/build-administration.shandbin/build-storefront.sh: substantially reworked,.env: the obsoleteMAILER_URLvariable removed.
After that, bin/console ran again and reported Shopware 6.7.16.1. If you have changed any of these files yourself, recipes:update shows conflicts like a Git merge. That is why it pays not to put your own customisations into recipe files but into separate config files.
Finishing and result
php bin/console system:update:finish
4.7 seconds, then 919 migrations (+197) and 256 tables (+26). Storefront and Administration returned HTTP 200. Earlier, the Composer output had contained three notices about features dropped in 6.8 (purge_all, enable_queue_stats_worker, http_cache). If you read them, you already know what will be due in your own configuration at the next major update.
Important: our test is the best possible case. An empty shop without plugins, without a custom theme, without customised configuration. In a real shop the actual work comes afterwards: getting plugins onto 6.7 versions, rebuilding the theme, checking Twig templates against changed blocks, testing payment and shipping methods. That takes days, not seconds. What such a project costs if you outsource it is covered in Shopware 6 pricing and costs.
The full procedure as a checklist
From our measurements, this is the order for a Shopware update on your own server:
Before (days in advance)
- Check the current version:
php bin/console --version. - Pick the target version. For patches: the newest. For minor releases: read the changelog. For majors: read
UPGRADE-6.x.md. - Check every plugin for a release for the target version. Unreleased plugins do not block the update; they just break afterwards.
- Run the update on a copy (staging) first, with the database loaded from a recent dump.
- Choose a quiet window, not Friday night and not during a sale.
In the maintenance window
php bin/console sales-channel:maintenance:enable --all
php bin/console cache:clear # otherwise maintenance has no effect
mariadb-dump --single-transaction shopware > before-update.sql
git add -A && git commit -m "before update"
composer require "shopware/core:6.7.16.1" --no-update
composer update "shopware/*" -W --no-scripts
# major only: composer recipes:update shopware/core (+ administration, storefront)
php bin/console system:update:finish
php bin/console sales-channel:maintenance:disable --all
php bin/console cache:clear
Afterwards
- Click through home page, category, product page, cart, and checkout up to payment selection yourself.
- Log into the admin and open an order.
- Search the log in
var/log/forCRITICAL. - Check the message queue: is
messenger:consumestill running? Workers must be restarted after an update, or they keep running with old code in memory. With a systemd service,systemctl restartis enough (how to set one up is shown in Create a systemd service). - Commit the new state.
Updating via the Administration instead of the console?
Since Shopware moved installation to Composer, updates without a command line run through the Shopware Web Installer, a single file shopware-installer.phar.php that you place in public/ and open in the browser. Behind the scenes it runs the same Composer steps.
We did not test the Web Installer for this article. It is meant for hosting packages without SSH access. Its limits follow from the principle: Composer needs memory and time, and both are often tightly capped on cheap shared hosting (PHP memory_limit, max_execution_time). If the process dies in the middle of the code swap, you are in exactly the state from step 2, just without a console to fix it. If you run your own server, the console is the better choice. How to set one up is shown in Linux server setup.
Common errors during a Shopware update
“Nothing to modify in lock file”: The version in composer.json is pinned exactly. Raise it first with composer require "shopware/core:NEW_VERSION" --no-update.
“the package is fixed to … (lock file version)”: A dependency has to move along. Allow it with -W (--with-all-dependencies).
“non-existent parameter” or “Class not found” right after a major update: The recipes are still on the old state. composer recipes, then composer recipes:update for the Shopware packages.
HTTP 500 with “Unknown column” in the log: Code is new, database still old. Run system:update:finish.
Maintenance mode on, shop still visible: HTTP cache. cache:clear.
Plugin cannot be activated after the update: It is not released for the new version. Install the plugin’s update or go back to the previous Shopware version.
Admin looks broken after the update: Usually a browser cache with old JavaScript files. Hard reload. If it persists: php bin/console assets:install, and for custom extensions rebuild the Administration (bin/build-administration.sh).
FAQ
How do I update Shopware 6?
With SSH access: back up database and code, enable maintenance mode, cache:clear, set the target version with composer require "shopware/core:VERSION" --no-update, run composer update "shopware/*" -W, then php bin/console system:update:finish, disable maintenance mode, cache:clear, test. Without SSH, via the Shopware Web Installer. Our small update took under 10 seconds of pure compute time.
How long does a Shopware update take?
The pure compute time is short: 6.9 seconds of composer update plus 3.0 seconds of migrations for the small update, 7.2 plus 4.7 seconds for the jump from 6.6 to 6.7, each in an empty test shop. A real shop adds backup, dump size, plugin updates, theme build, and above all testing. Plan an hour for a patch update and several days for a major update.
Is the shop offline during the update?
It should be. In our measurement the shop returned HTTP 500 between the code swap and the migration. Maintenance mode hides that from the moment the new code is fully in place, but not while Composer swaps the vendor/ directory. True zero downtime needs a maintenance page in the web server or a release switch via symlink.
Can I undo a Shopware update?
Yes, if you backed up first. Code back via Git, composer install, restore the database from the dump, clear the cache. For us that took 11.8 seconds. Rolling back only the code also worked in our test (old code ran on the new schema), but it is only an emergency exit. Orders placed between backup and rollback are lost in a database rollback.
Do I have to install every patch update?
Security-relevant patches, yes, and promptly. Shopware ships security fixes in patch versions; if you lag months behind, known vulnerabilities stay open. For shops that temporarily cannot update, Shopware offers a free security plugin that closes individual vulnerabilities without a version change. It does not replace updating in the long run.
Can I skip versions?
Within a line, yes: we went straight from 6.7.13.1 to 6.7.16.1, and the migrations of all versions in between ran in one pass. For major updates, the path goes through the last state of the old line, so first to the newest 6.6.10.x, then to 6.7.
What is the difference between system:update:prepare and system:update:finish?
prepare fires events that let plugins prepare for an update, and otherwise changes nothing visible. In our test the shop still returned HTTP 500 after prepare. finish runs the migrations, updates plugins, installs the assets, and clears the cache. Without finish, the update is not complete.
Why does my plugin no longer work after the update?
Because Shopware does not check active plugins for compatibility during the update. Our test plugin was only released up to 6.7.13 and kept running after the update to 6.7.16.1. The rejection only came when we tried to reactivate it. Before every update, check the release status of all extensions and install their updates too.
Do I need an agency for a Shopware update?
For patch and minor updates on a shop without custom code, the checklist above is enough if you have SSH access and have practised the rollback once. For a major update with custom plugins, a customised theme, or interfaces to ERP and shipping, support makes sense. The effort then lies in the adjustments, not in the update command.
Which PHP version do I need for Shopware 6.7?
According to the core’s composer.json, Shopware 6.7 runs on PHP 8.2 to 8.5. We tested with PHP 8.3.6. According to the current upgrade notes, Shopware 6.8 will require PHP 8.5, so if you move to 6.7 now, plan the PHP version at the same time.
Conclusion
A Shopware update consists of three commands, and the actual compute time in our tests was under 15 seconds, even for a jump across a major version. The risks sit in places that produce no error message. Maintenance mode only takes effect after cache:clear. While Composer swaps the code, it does not protect at all; even the maintenance page itself returns HTTP 500. An unreleased plugin silently keeps running after the update. And on the major update, Composer fails until you update the recipes, a step almost no quick guide mentions.
If you know that, an update fits into a quiet hour: maintenance on, clear the cache, take a dump, commit, update, finish, click through. And you have a rollback that demonstrably works in seconds.
Further reading: How a shop is set up in the first place, and which two installation errors occur despite a success message, is covered in Shopware Installation. How to create database backups whose restore actually works in an emergency is shown in MySQL Backup. And if your code is already in Git, the commands for commits, diffs, and ways back are in the Git commands list.
