Optimising Your Store for Speed and Performance

Page speed is not a vanity metric. It sits directly on the path between a curious visitor and a paying customer, and every extra second of load time gives someone a reason to leave. Google's own research on mobile pages has long pointed in the same direction: as load time climbs from one to three seconds, the probability of a bounce rises sharply. On a store, that bounce is a lost sale — and often a lost customer who never comes back.

The good news is that a lot of the heavy lifting is handled for you at the platform level. The rest comes down to a short list of habits that any merchant can adopt without touching code. This guide covers both: what Dirora does under the hood, and what you control on top.

Why speed pays for itself

Speed compounds across everything else you do. Faster pages convert better, rank better in search, and cost less to advertise to, because ad platforms reward landing pages that don't frustrate the people they send you. If you're investing in SEO for your store, performance is not a separate project — Core Web Vitals are a ranking signal, so a fast site and a well-optimised one are increasingly the same thing.

It also protects the money you've already spent. Driving traffic through ads or content and then losing a chunk of it to a slow-loading page is one of the most expensive mistakes in ecommerce, precisely because it's invisible in most dashboards. The visitors don't complain; they just leave.

Understanding Core Web Vitals

Core Web Vitals are Google's attempt to turn "does this page feel fast and stable?" into three measurable numbers. They're worth understanding because they map neatly onto what a shopper actually experiences:

• Largest Contentful Paint (LCP) — how long until the main content, usually your hero image or product photo, is visibly rendered. Aim for under 2.5 seconds. This is mostly an image and server-response problem.

• Interaction to Next Paint (INP) — how quickly the page responds when someone taps "Add to basket" or opens a menu. Aim for under 200 milliseconds. This is mostly a JavaScript problem.

• Cumulative Layout Shift (CLS) — how much the page jumps around as it loads. Aim for under 0.1. Nothing is more frustrating than reaching for a button that shifts the moment content above it loads.

You don't need to memorise the thresholds, but knowing which lever moves which metric helps you spend effort where it counts. Most of the wins below target LCP and CLS, because those are where merchants have the most influence.

A high-performance Go backend

Before a single pixel renders, the browser has to ask the server for the page — and how quickly the server answers sets the ceiling for everything else. Dirora's storefronts are served by a backend written in Go, a language built for exactly this kind of concurrent, high-throughput work. Fast server responses mean a low Time to First Byte, which feeds directly into a good LCP.

Behind that, product and catalogue data is cached aggressively so that repeat requests are answered from memory rather than recomputed from the database every time. The architecture is designed to keep response times low even when a flash sale or a viral post sends a spike of traffic your way. If you're curious about how the platform is put together, we've written about our microservices architecture in more depth. The practical upshot for you as a merchant is simple: the slowest, most expensive part of page rendering is handled, and it stays fast as you grow.

Server-side rendering

Dirora storefronts use server-side rendering (SSR). Instead of sending the browser an empty shell and a pile of JavaScript that then has to fetch data and build the page, the server assembles the finished HTML and sends it ready to display. The customer sees content almost immediately, rather than staring at a blank screen or a spinner while scripts execute.

This matters for two reasons. First, it's faster for real people, especially on mid-range phones and patchy mobile connections where heavy client-side JavaScript hurts most. Second, it's friendlier to search engines and social-media link previews, which can read the fully-formed HTML without having to run your JavaScript. SSR is one of those decisions that quietly improves both conversion and discoverability at the same time.

Automatic image optimisation

Images are almost always the largest assets on an ecommerce page, and they're where the biggest, easiest wins live. Dirora optimises images for you automatically: uploaded photos are converted to modern, efficient formats, and the platform generates multiple responsive sizes so that a phone downloads a small image while a large desktop display gets a sharper one. Nobody's mobile data gets spent downloading a 4000-pixel-wide product shot to display it 400 pixels wide.

Images below the fold are also lazy-loaded, meaning the browser only fetches them as the customer scrolls towards them. That keeps the initial page load lean and gets your hero content — your LCP element — on screen faster.

Automation only goes so far, though. The single most useful habit you can build is uploading sensible originals:

• Right-size before uploading. A product image displayed at 800 pixels wide doesn't need to start life at 5000. Export at a reasonable dimension and let the platform take it from there.

• Crop consistently. Uniform aspect ratios across your catalogue prevent layout shift and make collection pages look tidy and professional.

• Set alt text. It helps accessibility and image search, and it's a two-minute job per product.

If imagery is central to your brand, our guide to product photography pairs well with this — great photos that are also lightweight are entirely achievable.

Serve assets close to your customers

Static assets — images, fonts, scripts, stylesheets — are delivered through a content delivery network with sensible caching, so files are served from a location near your customer rather than making a long round trip on every visit. Combined with your storefront's own custom domain and automatic SSL, this keeps delivery both fast and secure. A modern HTTPS connection isn't just about the padlock; it's a prerequisite for the newer, faster web protocols that speed asset delivery. We cover the setup end to end in our custom domains and SSL guide.

Keep your theme and custom CSS lean

This is the area you control most directly. Dirora's visual theme editor lets you build sophisticated pages from drag-and-drop widgets, but like any powerful tool it rewards restraint. A few habits keep your storefront quick:

• Don't overload the homepage. Every additional carousel, embedded video and animation adds weight and work for the browser. Lead with what sells; move the rest below the fold or onto dedicated pages.

• Keep custom CSS tidy. If you use the custom CSS feature, avoid deeply nested selectors and delete rules you no longer use. The browser has to parse all of your CSS before it can finish rendering, so bloat here delays the whole page.

• Be cautious with third-party scripts. Analytics, chat widgets and marketing pixels each add JavaScript that can hurt your INP. Add the ones that earn their keep, and periodically remove the ones you've stopped using.

• Reserve space for dynamic content. Banners and embeds that load late are a common cause of layout shift. Where you can, give them a fixed slot so nothing jumps.

The theme editor's live preview and undo/redo history make it low-risk to experiment — change one thing, look at it, and roll back if it feels heavier. Our walkthrough on mastering the theme editor goes deeper on building pages that stay fast.

Measure, don't guess

Performance work goes wrong when it's driven by hunches. Test your live pages on a real mid-range phone over mobile data, not just your fast office laptop and broadband — that's the experience most of your customers are actually having. Free tools like Google's PageSpeed Insights and Lighthouse report your Core Web Vitals and, more usefully, tell you which specific asset or script is holding a page back.

Pair that with your store's own numbers. Your analytics dashboard shows where visitors drop off, and a page with an unusually high bounce rate is often hiding a performance problem. Fix, re-measure, and move on to the next bottleneck. Small, repeated improvements beat one big rewrite.

The takeaway

Most of the hardest performance engineering — the Go backend, server-side rendering, image optimisation, caching and CDN delivery — is handled for you, and it holds up as your traffic grows. Your job is the last mile: upload sensibly sized images, keep your theme and custom CSS lean, add third-party scripts sparingly, and measure on real devices. Do those few things consistently and you'll have a store that loads fast, ranks well, and turns more of your hard-won traffic into orders. When you're ready to build, our getting started guide is the place to begin.