Speed has always mattered in eCommerce, but for a long time it was treated like good posture—everyone agreed it was important, but nobody did much about it unless things got really bad.
That’s changing. Not because developers suddenly convinced business owners to care about technical metrics, but because the connection between speed and revenue has become impossible to ignore.
A one-second delay in page load can cost you 7% in conversions. That’s not a rounding error. For a store doing €500,000 annually, that’s €35,000 left on the table because pages load slower than they should. Every year. Compounding as your business grows.
The strange part is that most Shopware stores aren’t catastrophically slow. They load eventually. Products display. Checkout works. Everything functions. But “functional” and “fast enough to maximize conversion” are different standards, and the gap between them costs real money.
We’ve optimized dozens of Shopware stores over the years, and the pattern is consistent: stores that take performance seriously convert better than comparable stores that don’t, even when everything else—products, pricing, design, marketing—is essentially the same. Speed isn’t the only factor in conversion, but it’s one of the few factors you can control completely through technical execution.
The good news is that most performance problems in Shopware aren’t mysteries. They’re predictable, fixable issues that appear in store after store. You don’t need a complete rebuild or expensive infrastructure. You need to systematically address the handful of things that actually slow stores down.
Let’s walk through what makes Shopware stores fast, how to identify where yours is losing speed, and the specific fixes that deliver measurable improvements in both performance and sales.
Measure what customers actually experience, not what you think they experience
Before fixing anything, you need honest data about where you currently stand. Not how the site performs on your fast office connection using a desktop computer, but how it performs for actual customers on actual devices in actual conditions.
Most eCommerce traffic comes from mobile devices—usually over 60%. Those customers are on cellular connections that vary wildly in speed and reliability. They’re on older phones with less processing power. They’re multitasking, partially distracted, with limited patience for slow loads.
Testing your site on desktop wifi tells you almost nothing about what most customers experience.
Use Google PageSpeed Insights for your critical pages: homepage, category pages, product pages, cart, checkout. Focus on the Core Web Vitals metrics because these directly correlate with user experience:
Largest Contentful Paint (LCP) measures how long until the main content appears. Should be under 2.5 seconds. If you’re over 4 seconds, customers are bouncing before they even see your products.
First Input Delay (FID) measures responsiveness—how quickly the page reacts when someone clicks or taps. Should be under 100 milliseconds. Half a second of delay after clicking “add to cart” feels broken, even if it eventually works.
Cumulative Layout Shift (CLS) measures visual stability—how much the page jumps around as elements load. Should be under 0.1. When images pop in late and shift content around, customers click the wrong thing and get frustrated.
Also test on real devices. Load your store on your phone while standing outside on cellular. Try it on a three-year-old Android device, not just the latest iPhone. That uncomfortable, sluggish experience? That’s what a chunk of your customers deal with every day.
If you’re not regularly measuring performance and you don’t know your actual scores, you’re optimizing blind. Start with measurement.
Images are almost always the biggest problem
Product photos, lifestyle images, category banners, promotional graphics—images typically account for 60-80% of page weight in eCommerce stores. And most Shopware stores are shipping images that are vastly larger than they need to be.
We routinely see stores loading 3-4MB on the homepage where 80% of that weight is unnecessarily large images. A 4000×3000 pixel product photo being displayed at 400 pixels wide on mobile. The browser downloads the massive file, then scales it down. The customer pays in load time for resolution they never see.
Here’s what actually matters for image performance:
Serve appropriately sized images. If an image displays at 400 pixels on mobile, serve a 400-pixel version, not the full 4000-pixel original. Shopware supports responsive images through srcset attributes. Use them. Generate multiple sizes of each image and let the browser choose the right one for the device and screen size.
Use modern image formats. WebP images are typically 25-35% smaller than JPEGs at comparable quality. AVIF is even better but has less browser support. Shopware 6 can serve WebP if configured properly. The file size savings are too significant to ignore—a 200KB JPEG becomes a 130KB WebP with no visible quality loss.
Lazy load images below the fold. Don’t make customers wait for images they can’t even see yet. Load what’s immediately visible, then load the rest as they scroll. Shopware supports native lazy loading. Make sure it’s enabled and configured correctly.
Compress without destroying quality. Use tools like TinyPNG or ImageOptim to strip unnecessary metadata and compress files. You can often reduce image size by 40-60% without noticeable quality loss. Do this before uploading to Shopware, not after.
We’ve seen stores cut page load time by 50% just from proper image optimization. Nothing else changed—same design, same content, just appropriately sized and compressed images. That’s usually the single highest-impact performance improvement you can make.
The plugin and extension burden that compounds silently
This ties back to what we’ve written about plugin bloat, but it’s worth repeating in the performance context: every extension you install affects load time, and the impact compounds in ways that aren’t immediately obvious.
Each plugin typically adds JavaScript files, CSS files, API calls, database queries, or external resource loads. Individually, maybe that’s only 30-50KB and 100 milliseconds. But ten plugins? That’s 500KB and a full second added to your load time.
Some plugins are worse than others. Marketing and analytics tools are often the biggest offenders—tracking pixels, chat widgets, social proof notifications, popup builders. Each one wants to load early to capture every visitor, so they all fight for priority in the load sequence and end up blocking more important content.
Run a performance audit and check the network tab in your browser’s developer tools. Look at what’s actually loading. You’ll probably find:
- Multiple analytics scripts doing essentially the same thing
- Unused font files loading for every page
- Marketing pixels from campaigns that ended months ago
- Third-party scripts that load other third-party scripts
- Resources being loaded on pages where they’re not even used
The fix isn’t necessarily removing all plugins. It’s being intentional about which ones run, where they run, and how they load.
Ask for each plugin: Do we actually need this? Does it need to load on every page or just specific ones? Does it need to load immediately or can it load after the page is interactive? Can we replace multiple plugins with one better solution?
Defer non-critical JavaScript so it loads after the page is interactive. Async load scripts that don’t need to run immediately. Remove plugins that aren’t providing clear value. The performance gain from cleaning up plugin bloat is usually immediate and measurable.
Theme code quality matters more than theme features
Shopware themes vary wildly in code quality. Some are lean, well-optimized, and fast by default. Others are feature-bloated messes that look impressive in demos but perform terribly in production.
We see themes that load 15 JavaScript libraries for effects that barely anyone uses. Themes that include CSS for dozens of layout options even though you’re only using one. Themes with poorly written code that triggers unnecessary re-renders or blocks page rendering while loading resources.
If you’re using a commercial theme, check if there’s a performance-optimized version or settings to disable unused features. Many themes include every possible option enabled by default because it looks good in demos. Turn off what you’re not using.
If you’re running a custom theme, audit the code quality. Common performance killers:
Render-blocking resources that prevent the page from displaying until they load. Critical CSS should be inlined. Non-critical CSS and JavaScript should load asynchronously.
Unused code that ships to customers even though it’s never executed. Plugins and libraries loaded “just in case” rather than only when needed.
Inefficient JavaScript that runs on every page load doing work that could be cached or computed once. Poorly written animation code that causes layout thrashing.
Too many HTTP requests for resources that could be combined. Loading ten small JavaScript files instead of one combined file, each with its own connection overhead.
Good theme code is invisible—everything just works quickly. Bad theme code creates mysterious slowdowns that are hard to diagnose without technical expertise. If your theme is old or was built by developers who didn’t prioritize performance, that might be worth addressing.
Caching that actually works, not caching that’s just enabled
Shopware has built-in caching mechanisms. Most stores have them enabled. But “enabled” and “optimized” are very different states.
Full page cache should be enabled for pages that don’t change for every visitor—category pages, product pages, CMS pages. These can be served from cache instead of being generated fresh for each request. Huge performance win.
But we see stores where full page cache is technically enabled but misconfigured so it barely helps. Cache invalidation triggers too aggressively, clearing cache after every minor change. Cache warming isn’t set up, so the first visitor after cache clears gets a slow uncached page. Cache isn’t configured for different customer groups, so logged-in users don’t benefit.
HTTP caching headers should tell browsers and CDNs how long to cache resources. Images, fonts, CSS, JavaScript—these don’t change often and can be cached for days or weeks. If you’re not setting proper cache headers, browsers re-download the same resources on every visit.
Check your caching configuration. Make sure full page cache is actually serving most visitors. Verify that static resources have long cache lifetimes. Consider adding a CDN like Cloudflare to cache content closer to customers geographically.
Caching is one of those things that seems simple but has lots of details that matter. Get it right and you can serve pages 10x faster. Get it wrong and you’ve gained nothing despite technically having it “enabled.”
Database queries that slow down invisibly
Most store owners never think about database performance. It’s invisible. Either pages load or they don’t. But behind the scenes, poorly optimized database queries can kill performance even when everything else is configured correctly.
Common database performance problems in Shopware:
Missing indexes on columns that are frequently queried. Without proper indexes, the database has to scan entire tables to find data, which gets slower as your catalog grows.
N+1 query problems where the code makes one database query per product instead of fetching all products in a single query. Load a category with 50 products and you’re making 50+ separate database calls when you should make one.
Unoptimized queries that fetch more data than needed or use inefficient joins. Often this is plugin code written by developers who didn’t think carefully about database efficiency.
Large product catalogs without proper database maintenance. As your catalog grows, queries naturally slow down unless indexes are optimized and the database is regularly maintained.
You won’t see these problems without profiling tools or database query logs. But if your store has 10,000+ products and pages are slower than they used to be despite no obvious changes, database optimization is probably worth investigating.
This is technical work that usually requires developer expertise, but the performance gains can be substantial, especially for stores with large catalogs or complex product configurations.
Hosting that matches your actual traffic patterns
You can optimize everything perfectly and still have performance problems if your hosting isn’t adequate for your traffic volume and patterns.
Shared hosting is fine for small stores with steady, predictable traffic. But if you’re running sales events or getting traffic spikes from marketing campaigns, shared resources often can’t handle the load. Pages slow down or crash exactly when you need them working best.
Dedicated or cloud hosting with proper resource allocation solves this, but it requires configuration. You need enough memory for caching, enough CPU for peak traffic, fast disk I/O for database operations. “Unlimited” hosting usually has resource limits that kick in when you actually need unlimited.
Consider managed Shopware hosting from providers who specialize in it. They’ve already optimized the server configuration, caching layers, and database setup for Shopware specifically. You pay more than basic hosting but get performance and reliability that’s hard to replicate on generic hosting.
Also think about geographic distribution. If you’re selling across Europe, hosting in Germany might be fast for German customers but slower for customers in Spain or Poland. A CDN helps, but actual server location matters for dynamic content that can’t be fully cached.
Hosting is one area where you sometimes need to spend money to solve performance problems. But the cost difference between adequate and inadequate hosting is usually smaller than the revenue impact of slow pages.
Checkout speed matters more than any other page
You can have a slow homepage and still make sales if checkout is fast. You can’t have slow checkout and expect good conversion, no matter how fast everything else is.
Checkout is where revenue happens. Every millisecond of delay, every moment of unresponsiveness, every loading spinner—these directly impact whether customers complete purchases or abandon.
Priority one for checkout performance: minimize third-party scripts. Every payment provider, fraud detection tool, analytics tracker, and marketing pixel adds overhead. Only load what’s absolutely necessary for checkout to function. Everything else can wait or be excluded from checkout pages entirely.
Priority two: optimize form interactions. The checkout form needs to respond instantly to input. Autocomplete, address validation, tax calculation—these should feel immediate. If there’s noticeable lag between typing an address and seeing the validated result, that’s a conversion killer.
Priority three: reduce checkout steps and page loads. Every additional page is another opportunity for slowness to cause abandonment. Single-page checkout isn’t always better, but fewer pages usually is.
We’ve seen stores optimize everything except checkout, then wonder why conversion is still low. Checkout is the one place where performance absolutely cannot be compromised. If you have to choose between a fast homepage and fast checkout, choose checkout every time.
The mobile experience that most stores ignore
We mentioned testing on mobile earlier, but it deserves its own section because mobile performance is usually significantly worse than desktop and most stores don’t realize how bad it is.
Mobile devices have less processing power, less memory, slower connections. The same page that loads in 2 seconds on desktop might take 6 seconds on mobile. And mobile users are less patient—they’re often on-the-go, distracted, with lower tolerance for slow experiences.
Check your analytics. What percentage of traffic is mobile? What’s your mobile conversion rate compared to desktop? If mobile traffic is 65% but mobile conversion is significantly lower, performance might be a major factor.
Mobile-specific optimization:
Reduce JavaScript execution. Heavy JavaScript that’s barely noticeable on desktop can make mobile pages feel sluggish and unresponsive.
Prioritize above-the-fold content. Get something visible and interactive fast, even if the full page takes longer to complete loading.
Optimize tap targets and form interactions. Slow form responsiveness on mobile is especially frustrating because the keyboard and form fields dominate the screen.
Test on actual devices, especially older Android phones. These represent a significant portion of mobile traffic and perform much worse than new iPhones.
Treating mobile as an afterthought means ignoring the majority of your traffic. Mobile performance optimization often requires different priorities than desktop—what matters most is different on smaller screens and slower processors.
What good performance actually feels like
Fast stores don’t feel fast—they feel effortless. You click a product and it appears. You scroll and images are already there. You tap “add to cart” and get immediate feedback. Everything responds the moment you interact with it.
There’s no waiting. No spinning loaders. No blank screens while content loads. No jumpy layouts as images pop in. It just works, instantly, the way customers expect digital experiences to work in 2025.
This isn’t about achieving perfect PageSpeed scores or hitting arbitrary metrics. It’s about removing the friction between customer intent and customer action. Every moment of delay is friction. Every second of uncertainty is doubt. Every sluggish interaction is a reason to leave.
The stores that convert best aren’t necessarily the ones with the best products or the lowest prices. They’re often just the ones that make it easiest to shop and buy, and speed is a huge part of that ease.
The business case for caring about speed
Speed optimization isn’t free—it requires time, expertise, and sometimes money for better hosting or development work. But the ROI is usually better than almost any other investment you can make.
Marketing gets you traffic. Good products get people interested. But speed determines how many of those interested visitors actually convert. A 10% improvement in site speed can translate to a 5-10% improvement in conversion rate. For a store doing €500k annually, that’s €25k-50k in additional revenue.
Compare that to what it costs to achieve similar revenue gains through increased marketing spend. How much would you need to spend on ads to drive an additional €25k in sales? Probably more than it would cost to properly optimize your store’s performance.
Speed improvements also compound with other optimization efforts. Faster pages mean better ad performance (Google uses page speed in quality score). Better mobile performance means more of your mobile traffic converts. Faster checkout means fewer abandoned carts. All of these work together.
The stores that treat performance as a critical business metric rather than a technical nice-to-have consistently outperform those that don’t. Not because speed is magic, but because speed is foundational to everything else working properly.
If your store is slower than it should be
Most Shopware stores have performance issues they don’t know about because nobody’s measuring or nobody’s prioritizing fixes. If you’ve never run a proper performance audit, you almost certainly have low-hanging fruit that could dramatically improve speed with relatively little effort.
You can start with the basics yourself: run PageSpeed Insights, optimize images, review your plugin list, check caching configuration. These don’t require deep technical expertise and can yield significant improvements.
For deeper optimization—database tuning, theme code improvements, advanced caching strategies, checkout optimization—you probably need expertise. Someone who knows Shopware performance specifically and has optimized enough stores to recognize patterns and prioritize fixes effectively.
That’s work we do at BrandCrock. Taking the time to properly audit performance across the entire store, identify the specific bottlenecks affecting your conversion, prioritize fixes by impact, and implement them systematically. Not chasing perfect scores, but targeting the improvements that actually increase sales.
If your store is slower than it should be and you suspect it’s costing you conversions, reach out. We’ll look at your specific performance profile and tell you honestly what we see—what’s fixable, what the likely impact would be, and whether focused optimization work makes sense for your situation.
Because speed isn’t about bragging rights or hitting arbitrary metrics. It’s about removing friction from the buying process and keeping revenue that’s currently leaking away through preventable performance problems. Your customers are ready to buy. Make sure your store is fast enough to let them.
Vaid Ali
Nov 23, 2025
