Shopware 6.7 represents a significant leap forward in open-source e-commerce architecture, bringing refined Symfony integration, enhanced media processing pipelines, and streamlined plugin development workflows. However, the platform’s capabilities are only as strong as the environment that hosts them. Misaligned dependencies don’t merely trigger installation errors; they silently degrade checkout throughput, break asset compilation, and corrupt asynchronous task queues. This guide explains exactly what Shopware 6.7 requires, why each component matters, and how to configure your infrastructure for production readiness.
Core Runtime Environment
At the foundation sits PHP 8.2 or 8.3. Shopware 6.7 fully leverages modern PHP semantics: improved JIT performance, typed properties, match expressions, nullsafe operators, and refined attribute routing. The framework’s dependency injection container, event dispatcher, and kernel boot sequence all depend on these capabilities. While the installer validates mandatory extensions, you should proactively verify optional but critical modules like opcache, intl, mbstring, imagick, bcmath, and zlib. Missing any of these will surface as cryptic errors during data migration or third-party app installation.
Database flexibility has expanded in 6.7. The platform officially supports MySQL 8.0+, PostgreSQL 14+, and MariaDB 10.5+. This allows teams to adopt enterprise clustering, multi-region replication, or open-source alternatives without sacrificing transactional guarantees. Shopware’s ORM abstracts vendor-specific syntax, but proper storage engine configuration remains non-negotiable. InnoDB or MariaDB's native implementation must handle foreign key constraints, row-level locking, and full-text indexing correctly. Enable strict mode during provisioning to prevent silent type coercion that can corrupt pricing calculations or inventory counts.
Web servers benefit from mature reverse proxy compatibility. Nginx 1.21+ or Apache 2.4+ are fully supported, with configurations emphasizing PHP-FPM socket pooling, HTTP/2 or HTTP/3 termination, and secure TLS handshakes. Shopware’s router expects standard forwarding headers for accurate client IP resolution and rate-limiting logic, particularly when deployed behind CDNs, load balancers, or WAFs. Ensure X-Forwarded-Proto, X-Real-IP, and Strict-Transport-Security are propagated correctly to maintain session consistency and cookie security across edge nodes.
Infrastructure & Performance Stack
Memory allocation directly dictates request handling capacity. While 1 GB of RAM can boot the setup wizard, production deployments require a minimum of 2 GB dedicated to PHP-FPM workers, plus additional headroom for background processes like cron runners and media transcoders. Each PHP worker typically consumes 50–80 MB depending on loaded extensions and cached metadata. A pool managing 30 concurrent requests will easily demand 1.5 GB alone. Disk I/O should leverage NVMe or SSD storage. Shopware’s theme compiler, asset pipeline, and plugin registry generate substantial temporary files during builds, making fast read/write throughput essential for continuous integration workflows.
Caching is mandatory rather than optional in 6.7. Redis or Memcached must be provisioned for HTTP cache tags, session persistence, and distributed rate limiting. The platform implements a multi-tier caching strategy: application-level OPcache for compiled PHP bytecode, framework-level metadata caching for service definitions, and full-page HTTP caching via Symfony’s reverse proxy abstraction. Without a dedicated cache backend, the system falls back to filesystem storage, which degrades under concurrent load and breaks tag-based invalidation patterns required for dynamic promotions, customer group pricing, and regional tax rules.
Search functionality has shifted entirely to OpenSearch/Elasticsearch 8.x. Shopware 6.7 decouples catalog indexing into asynchronous background workers. You’ll need a dedicated search cluster with appropriate JVM heap allocation and shard distribution for your inventory size. A typical production node requires 4 GB of heap memory, G1GC garbage collection tuning, and at least two data nodes for fault tolerance. Network latency between application servers and the search cluster should remain under 5 ms to prevent timeout penalties during category browsing or autocomplete queries. Proper index mapping, custom analyzers, and synonym dictionaries directly dictate relevance scoring out of the box.
Development & CLI Tooling
Behind the scenes, Shopware 6.7 relies on a contemporary development ecosystem. Composer 2.5+ is mandatory for dependency resolution, particularly for Symfony components, shop-specific plugins, and cross-vendor autoloaders. Node.js 18 or 20 powers the frontend build pipeline, including Tailwind CSS compilation, Vue 3 component bundling, and Webpack asset versioning. Git, Docker (optional but highly recommended), and a local OpenSearch instance ensure development parity with staging environments.
Here’s how to align your PHP-FPM pool for Shopware 6.7:
; php-fpm.d/shopware.conf
[shopware]
user = www-data
group = www-data
listen = /run/php/php8.3-fpm.sock
pm = dynamic
pm.max_children = 50
pm.start_servers = 15
pm.min_spare_servers = 10
pm.max_spare_servers = 25
php_admin_value[opcache.enable] = 1
php_admin_value[post_max_size] = 128M
php_admin_value[max_execution_time] = 300
This configuration stabilizes worker allocation while preventing memory exhaustion during media uploads or checkout API calls. Adjust max_children by dividing total available RAM by estimated per-worker usage, preserving 30% for the OS and auxiliary services.
For database initialization, Shopware 6.7 expects UTF8MB4 with proper collation:
CREATE DATABASE shopware DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
GRANT ALL PRIVILEGES ON shopware.* TO 'sw_user'@'localhost' IDENTIFIED BY 'strong_password';
FLUSH PRIVILEGES;
While 6.7’s installer handles schema migration, manual database creation should mirror production constraints to avoid runtime encoding collisions during plugin data imports or legacy cart migrations.
Verification & Best Practices
Before deployment, validate your environment using Shopware’s built-in checker:
bin/check-system-requirements.php
This script inspects PHP extensions, memory limits, disk permissions, and OpenSearch connectivity. Always re-run it after modifying server configurations or installing new extensions. For production, disable display_errors, configure error_reporting to log only warnings and critical exceptions, and route sessions to Redis instead of file-based storage.
Timezone consistency is another frequent failure point. Shopware 6.7 stores timestamps in UTC internally but relies on your server’s date.timezone directive for cron scheduling and third-party API webhooks. Mismatched timezones cause scheduled price changes or email campaigns to fire prematurely or delay, directly impacting customer experience. Additionally, align your CRON setup with Symfony’s Messenger component. The platform delegates heavy lifting—email queues, sitemap generation, inventory reconciliation, and payment webhook processing—to asynchronous handlers. Running bin/console messenger:consume async via supervisor ensures reliable task execution without blocking HTTP threads.
Conclusion
Shopware 6.7 is engineered for scale, but its modern architecture demands a disciplined infrastructure strategy. By aligning your PHP runtime, database configuration, caching layer, and development toolchain with the platform’s documented requirements, you eliminate silent degradation points and future-proof your e-commerce stack. System readiness isn’t merely about passing an installer check; it’s about enabling Symfony’s dependency injection, OpenSearch’s relevance algorithms, and Shopware’s plugin ecosystem to perform as designed. Validate early, document environment deviations carefully, and treat infrastructure provisioning as a continuous deployment priority rather than a one-time configuration task. Your shop’s performance, reliability, and developer velocity will reflect that investment from day one.