Shopware 6 has long relied on its plugin system as the primary vehicle for customization. However, version 6.7 marks a decisive architectural shift with the introduction of the App System as a first-class integration paradigm. This isn’t just a marketing update—it reflects Shopware’s migration toward modern, cloud-native commerce ecosystems. If you’re planning an integration in Shopware 6.7 or beyond, choosing between Apps and Plugins will directly impact your project’s scalability, security posture, and maintenance overhead. Let’s break down both systems and clarify when to use each.
The Plugin System: Depth Meets Tight Coupling
Traditional Shopware plugins live inside the custom/plugins directory, register via the extension manifest, and bootstrap directly into the Shopware kernel. They execute within the same PHP process, share the same database connection, and enjoy unfettered access to Symfony services, internal event subscribers, and template inheritance. This architecture makes Plugins exceptionally powerful for:
- Deep checkout or admin UI modifications
- Custom entity extensions that must sync instantly with core tables
- High-performance event listeners that cannot tolerate network latency
- Legacy ecosystem compatibility where partner stores still expect plugin bundles
However, this power comes with architectural debt. Plugins share memory and execution context with the storefront and administration. A memory leak or unhandled exception can cascade across the entire application. Scaling horizontally becomes difficult because plugins must be deployed in lockstep with Shopware core. Additionally, debugging requires navigating a monolithic request lifecycle, and security boundaries are virtually non-existent: a compromised plugin effectively gains root access to Shopware’s data layer.
The App System (Shopware 6.7+): Decoupled by Design
The App System flips the traditional model entirely. Apps are standalone Symfony applications that communicate with Shopware exclusively through REST/GraphQL APIs and webhooks. They reside outside the Shopware process—typically in their own Docker container or cloud runtime—and maintain a completely isolated database schema. Shopware 6.7 refined this system with stricter JWT-based authentication, automated webhook routing, and streamlined CLI installation flows.
Apps excel at:
- Third-party SaaS integrations (ERP, CRM, PIM, headless CMS)
- Multi-tenant partner extensions requiring tenant isolation
- AI/ML pipelines that process order or customer data asynchronously
- Microservices architectures where resilience matters more than kernel access
Because Apps are decoupled, a crash in your integration code will never take down the storefront. They scale independently, support native CI/CD pipelines, and enforce strict security boundaries via scoped API tokens. The trade-offs are real: HTTP round-trips introduce latency, data synchronization requires careful webhook retry logic, and you lose direct access to Shopware’s internal services. You must design around eventual consistency rather than transactional immediacy.
Core Architectural Differences
| Aspect | Plugin | App (6.7+) |
|----------------------|-----------------------------------------|---------------------------------------------|
| Execution Context | In-kernel, shared PHP process | Standalone container/runtime |
| Data Access | Direct ORM, same DB schema | API calls & webhooks, isolated database |
| Security Boundary | Full Symfony/service access | JWT-scoped API permissions & OAuth2 tokens |
| Deployment Model | custom/plugins, manual or CI-sync | Docker, CLI install, Commerce Cloud Store |
| Failure Isolation | Low (shared memory/process) | High (process/container boundary) |
| Update Cadence | Tied to Shopware core releases | Fully independent |
| Best Fit | Kernel-level customization | External services & headless ecosystems |
When to Choose Which?
Pick a Plugin when your integration must modify core Shopware behavior in real time: rewriting checkout steps, injecting custom admin grids, overriding template inheritance chains, or listening to internal events like entity_created for immediate data transformation. Plugins remain unmatched for native UI/UX work and performance-sensitive logic.
Choose an App when building integrations with external systems, requiring independent scaling, strict tenant isolation, or cloud-native deployment patterns. Apps are the clear winner for payment gateways, AI analytics pipelines, multi-language PIM sync, headless commerce layers, and any scenario where process isolation directly translates to business continuity.
Modern App Setup in Shopware 6.7+
Here’s how a modern App handles a Shopware webhook for order creation:
// src/Subscriber/OrderCreatedWebhookSubscriber.php
namespace App\Subscriber;
use Shopware\AppFramework\Webhook\ShopwareWebhookEvent;
use Shopware\AppFramework\Webhook\ShopwareWebhookPayload;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
class OrderCreatedWebhookSubscriber implements EventSubscriberInterface
{
public static function getSubscribedEvents(): array
{
return [ShopwareWebhookEvent::class => 'handleOrder'];
}
public function handleOrder(ShopwareWebhookPayload $payload): void
{
$orderData = $payload->getEntity('orders');
// Process outside Shopware's context
$client = new \GuzzleHttp\Client();
$client->post('https://external-api.com/webhooks/order', [
'json' => ['order_id' => $orderData->getId()],
]);
}
}
The App’s composer.json must require shopware/app-framework, and routes are registered via config/routes.yaml:
shopware_app_webhooks:
resource: '@App/Subscriber/'
type: annotation
Installation is handled via CLI (bin/app install) or the Commerce Cloud Store, with JWT tokens automatically exchanged during setup. All API calls back to Shopware should use Shopware\AppFramework\Http\Client\ShopwareClient for authenticated requests.
Conclusion
Shopware 6.7 doesn’t retire Plugins—it expands your architectural toolkit. Plugins remain essential for deep, kernel-level customization and performance-critical logic. Apps represent the future of integrations: secure, scalable, resilient, and cloud-ready. Evaluate your integration’s latency tolerance, security requirements, and deployment strategy before committing to one path. For external services, partner ecosystems, or headless architectures, the App System is the definitive choice. For native storefront modifications or immediate data transformations, Plugins still hold their ground. Master both, and you’ll build integrations that are both powerful and future-proof in Shopware 6.7+.