Verified on Shopware 6.7

Why This Article Exists

Every Shopware developer eventually gets "the request" - a feature that's not in the docs, not in any plugin, and the client needs it yesterday. After building dozens of custom Shopware 6 solutions, here are the 10 features clients ask for most - and how we approach each one.

1. Custom Product Configurator

The request: "We sell custom-printed products. Customers need to upload images, choose colors, add text, and see a live preview."

Technical approach:

  • Custom CMS element for the configurator UI
  • Storefront JavaScript plugin with canvas rendering for preview
  • Custom line item payload to store configuration choices
  • Cart processor to calculate price additions based on options
  • Order subscriber to attach configuration data to the order for production

Key challenge: The live preview. We used HTML5 Canvas to composite the customer's choices in real-time. The configuration is serialized as JSON in the line item payload, preserved through the entire checkout flow.

2. Multi-Warehouse Stock Management

The request: "We have 3 warehouses. Stock should decrement from the nearest warehouse to the customer. Show 'Ships from [city]' on the product page."

Technical approach:

  • Custom entity: warehouse with location (lat/lng), stock levels per product
  • Custom entity: warehouse_stock (product_id, warehouse_id, quantity)
  • Product subscriber to aggregate total stock across warehouses
  • Cart processor to assign warehouse based on shipping address
  • Order placed subscriber to decrement stock from the assigned warehouse
  • Storefront extension to show warehouse info on product detail page

Key challenge: Warehouse selection during checkout. The shipping address might change - so warehouse assignment happens in a cart processor that re-evaluates on every cart update.

3. B2B Customer-Specific Pricing

The request: "Each B2B customer has negotiated prices. They should see their prices everywhere - listing, detail page, cart."

Technical approach:

  • Custom entity linking customer → product → price
  • Custom price collector that loads customer-specific prices
  • Cart processor to override product prices
  • Storefront subscriber to inject custom prices into product listings
  • Admin module to manage customer-price assignments

Key challenge: Performance. Loading custom prices for an entire listing page (48 products) per request is expensive. Solution: aggressive caching with cache invalidation when prices change. Use the HTTP cache tag system to invalidate specific product pages when a customer's price is updated.

4. Scheduled Content Publishing

The request: "Marketing wants to prepare campaigns and have them go live automatically at midnight on launch day."

Technical approach:

  • Custom fields on CMS pages: publish_at and unpublish_at datetime fields
  • Scheduled task (cron) that checks for pages due to publish/unpublish
  • CMS page subscriber that filters out unpublished pages from storefront
  • Admin UI extension showing publishing schedule
  • Cache invalidation when a page transitions state

Key challenge: Cache invalidation timing. If a page should go live at midnight but the cache TTL is 1 hour, it won't show until 1 AM. Solution: schedule cache invalidation for the exact publish time using a delayed message in the message queue.

5. Custom Import/Export with ERP Mapping

The request: "Our ERP exports CSV files with their own column names and product structure. Import them into Shopware without manual mapping every time."

Technical approach:

  • Custom admin module with mapping profile builder (ERP field → Shopware field)
  • File upload handler with format detection (CSV, XML, JSON)
  • Async message handler for large imports (don't block the admin)
  • Transformation pipeline: parse → validate → map → upsert
  • Import log with per-row error reporting

Key challenge: Variant handling. ERPs often have a flat structure where each variant is a row, but Shopware expects a parent-variant hierarchy. The mapper needs to detect and group variants by parent product number.

6. Dynamic Shipping Rules

The request: "Free shipping over 50 EUR, except for heavy items. Heavy items ship via freight carrier with calculated pricing. Islands have a surcharge."

Technical approach:

  • Extend the Rule Builder with custom rules: CartWeightRule, ShippingZoneRule
  • Custom shipping method price calculator
  • Product custom field for weight class (standard, heavy, oversized)
  • Postcode-based zone mapping for island detection
  • Cart processor to split shipments when mixed (standard + heavy)

Key challenge: Split shipments. Shopware doesn't natively support multiple shipments per order. The workaround: show the combined shipping cost as a single line but store the split information in order custom fields for fulfillment.

7. Wishlist Sharing

The request: "Customers want to create wishlists and share them via link with friends and family. Like a wedding registry."

Technical approach:

  • Custom entity: shared_wishlist with unique token, name, and product list
  • Store API custom route for creating and retrieving shared wishlists
  • Storefront controller for the public shared wishlist page
  • "Add all to cart" functionality on the shared list
  • Optional: password protection for private lists

Key challenge: Guest access. The shared wishlist URL must work for non-logged-in users. We create a public storefront route that doesn't require authentication but uses the token for access control.

8. Multi-Domain SEO

The request: "We sell in DE, AT, and CH. Each has its own domain but shared catalog. SEO must be perfect - hreflang, canonical URLs, country-specific sitemaps."

Technical approach:

  • Three sales channels, one per country, each with its own domain
  • Shared product catalog with per-sales-channel visibility
  • hreflang tag generation in theme: link between the three versions of each page
  • Per-sales-channel sitemap generation
  • Canonical URL pointing to the primary (DE) version
  • Language/country selector in the storefront header

Key challenge: hreflang implementation. You need to know the URL of the same product in all three sales channels. We built a subscriber that pre-generates a mapping table of product URLs across sales channels, cached and invalidated when SEO URLs change.

9. Custom Checkout Steps

The request: "Add a 'Gift Options' step between shipping and payment where customers can add gift wrapping and a message."

Technical approach:

  • Custom checkout step by extending the checkout Twig templates
  • Storefront JavaScript plugin to handle the step navigation
  • Cart line item for gift wrapping (with price)
  • Custom field on the order for the gift message
  • Order confirmation email template extension to show gift options

Key challenge: Checkout flow state management. The gift options need to persist even if the customer goes back and forth between steps. We store the selections in the cart's extensions data, which persists across the entire checkout flow.

10. Real-Time Inventory Display

The request: "Show 'Only 3 left!' on product pages. Update in real-time if someone else buys while they're browsing."

Technical approach:

  • Stock level display in product detail Twig template with thresholds
  • Server-Sent Events (SSE) endpoint for real-time stock updates
  • Order placed subscriber that broadcasts stock changes
  • Storefront JavaScript that listens for SSE events and updates the DOM
  • Configurable thresholds: "In stock" (>10), "Low stock" (3-10), "Only X left!" (<3)

Key challenge: Performance at scale. SSE connections are persistent - with 1000 concurrent users, that's 1000 open connections. Solution: use a separate lightweight Node.js service for SSE broadcasting, with Shopware pushing stock changes to it via webhook. Don't burden the PHP process.

Patterns Across All 10

Looking at these projects, some patterns emerge:

  1. Custom entities are your friend - don't try to squeeze everything into custom fields
  2. Cart processors solve most pricing/discount needs - learn the cart pipeline well
  3. Cache invalidation is always the hardest part - plan for it from the start
  4. Async everything external - never call external APIs synchronously in a storefront request
  5. Test with real data volumes - 10 products work fine, 10,000 products reveal the problems

Have a feature that's not in this list? Chances are we've built something similar. Let's talk.