I build the storefront, then I go and sell through it.

A lot of "Arabic ready" stores are English stores with the words swapped. This one mirrors properly: layout direction, navigation, typography, product templates, the components inside them, and locale-aware URLs. The switcher runs off Shopify's native localisation — a dropdown in the desktop top bar and a pill toggle at the bottom of the mobile drawer — sitting on top of the translation layer rather than fighting it.

The interesting part was diagnosing why it was invisible. The code was already there and correct; Arabic simply wasn't published as a locale, so the storefront saw one available language and rendered nothing. Publishing the locale and attaching it to the UAE market brought the whole thing to life without a single theme edit. Every custom component I've built since ships with its Arabic copy in the same file, so the second language never falls behind the first.

Upholstery is the classic Shopify trap. A sofa in nine fabrics across three sizes is 27 variants that all cost the same and all need photography, and it drowns the catalogue and the feeds. So the fabric isn't a variant here. It's a slide-in drawer of grouped swatches with a large hover preview, and the choice is written onto the cart line as a line-item property that prints on the order for the workshop.

Clicking a swatch also swaps the main gallery image where a real photo of that combination exists, so a customer picking Sage on a Valencia sees the Sage sofa, not the studio default. Adding a sofa is a config edit rather than a build, and the collection cards badge themselves — each card lazily checks its own product page for a selector and pulls the first four swatches in as round mini-swatches. Give any product the drawer and it starts advertising itself everywhere in the store on its own.

King is the stock size. Queen and Super King are made to order, take three to four weeks and can't be returned — and customers were finding that out after paying. The fix is a dialog on those two sizes with a scaled diagram drawn from the real mattress footprint, the measurements, the terms, a tick-box and a Confirm button. Add to Cart doesn't work until it's acknowledged.

What makes it defensible rather than decorative is what happens on confirm: it stamps a visible Made to order property plus a hidden ISO timestamp onto the line. When a customer disputes a three-week lead time, there's a record on the order showing they ticked the box and when. The gate runs as a document-level capture listener so it fires ahead of the theme's own form handler, and the dynamic checkout button is hidden while an unacknowledged size is selected — otherwise Shop Pay just walks straight around it.

I only drew diagrams for sizes the owner actually confirmed. Inferring bed dimensions from a standard chart would have put a wrong number on a non-returnable product.

The workshop can build a sofa at any length in that range, so the store should sell it that way. I proposed variants twice and was told no twice — correctly, because 18 length variants per sofa would have wrecked the catalogue. The accepted model is one product, one price and a slider.

Price scales linearly from the sofa's own rate — its live price divided by its standard length — rounded to the nearest five dirhams, plus a flat customisation fee. Since the base price is read live, putting the sofa on sale needs no code change. The money itself rides on a separate AED 1 helper product, quantity equal to the upgrade in whole dirhams, unpublished from every channel except the online store so it never leaks into Google or Meta feeds.

Which creates the real problem: two cart lines that must live and die together. A cart guard ties them with a hidden key and runs on every page — orphaned charge gets removed silently, mismatched quantity gets corrected silently, and a customised sofa with no charge raises a pop-up rather than letting the order through underpriced. Turning it on for another sofa is two metafields, no code.

A custom-cut travertine table is a heavy, expensive, non-returnable object, and "40 × 40 × 45" means very little to most people standing in their living room. This one gives nine priced sizes and a pop-up that renders the block to scale as you change them, so the difference between two sizes is something you see rather than something you calculate — with the non-returnable terms behind a tick-box before it will add to cart.

Furniture sells in rooms, not in single objects, so the product page needed a way to show the rest of the set. The section reads a metafield on the product, so the merchandising team curates it themselves without a developer, and it removes itself automatically when a linked product is deactivated. That last part matters more than it sounds: the usual failure of a hand-built "complete the look" block is that it quietly keeps pointing at a discontinued product for months.

Pagination on a furniture catalogue is where browsing sessions go to die. Collection pages, /collections/all and search now load continuously, and the pagination never appears. The script keys off the next-page link and re-scans on section load and DOM mutation, so it survives the theme's AJAX filter and sort swaps instead of breaking the first time someone sorts by price.

The loader was the fun bit. The brand logo is white on transparent — built for the dark header, so on a light collection page it's simply invisible. Rather than commission a second asset, the spinner paints the logo as a CSS mask filled with currentColor, so it inherits the page's text colour and works on any background, in either theme, forever.

The home page was five category banners stacked vertically — the layout every Shopify furniture store defaults to, and the reason nobody scrolls past the second one. It's now a full-screen vertical slideshow closer to how Zara Home presents a season: one image at a time, at full height, with the category as a destination rather than a tile.

There's a second sequence for the commercial side of the business — a "For Projects" slideshow separating hospitality and fit-out enquiries from retail customers, because those two audiences want completely different things and were previously landing on the same page.

In the UAE, trust signals are specific and local. The product-page badge section covers Apple Pay and Google Pay, Amex, Tabby for buy-now-pay-later, and the Fazaa, Esaad and DEWA employee programmes that a large slice of Dubai customers actually check for before buying furniture. It's a block-based section, so marketing adds a new provider by uploading a logo in the theme editor rather than asking me.

Same category of work: a branded shimmer splash on first load, and a bilingual showroom location section, because "where can I come and sit on it" is the single most common message a furniture store gets.

Sale items were still accepting discount codes. Nobody had designed that; it accumulated, one campaign at a time, across manual codes, Flow-generated codes, loyalty rewards and email automations. The result was double discounts on exactly the stock with the least margin left.

I built a Full Price smart collection — everything without a compare-at price — and rescoped every affected code to it, then verified them. Credit notes and trade codes were deliberately left alone, because those are commercial commitments, not promotions. The structure means new products inherit the right behaviour automatically instead of depending on somebody remembering.

The catalogue arrived as supplier boilerplate — the same paragraph on forty products, no intent mapping, nothing an answer engine could extract a fact from. Rewriting 3,000 products by hand isn't a project, it's a career, so I built the pipeline instead: intent-mapped titles and descriptions, fact-dense body copy structured so a model can lift a specification and cite it, generated through Claude and MCP workflows with the store as the source of truth.

The measure isn't just rankings any more. It's whether the brand gets quoted — in AI Overviews, in ChatGPT, in Perplexity — and that needs facts stated plainly, marked up properly and linked internally, not adjectives.

Years of apps had each helpfully injected their own schema. The store was emitting duplicate and conflicting Product and Organization blocks with syntax errors inside them, which is worse than emitting none — Google can't tell which one is true, so it trusts neither. I audited every template, removed the orphaned blocks, and rebuilt Product, FAQ, Organization and local business markup as valid JSON-LD with consistent NAP details for Dubai local search.

Rather than publishing on a schedule and hoping, I built a repeatable pipeline around what people in the UAE actually type and ask — high-intent local terms, People Also Ask questions, and the prompts people put to AI assistants when they're furnishing a place. Each piece is structured answer-first with FAQ markup, so it's eligible for a snippet and legible to an answer engine on the same page.

Furniture has a brutal retention profile — somebody buys a sofa and then genuinely doesn't need anything for two years. Treating that like fashion email gets you unsubscribes. So the flows are built around the room instead of the calendar: what goes with what you bought, when a delivery actually lands, and what a second room looks like.

Segmented email and WhatsApp flows took repeat purchase to 30% of revenue within 12 weeks. WhatsApp matters disproportionately in this market; it's where UAE customers already are, and open rates aren't comparable to email. The transactional and abandoned-checkout templates are hand-coded to match the storefront's design system rather than sitting in the default template a customer has seen from fifty other stores.

With a workshop building to order, delivery dates move. Someone in customer service was noticing that and messaging the customer manually — which meant it happened reliably on quiet days and unreliably on busy ones, when it matters most. A Shopify Flow now detects the change on the order and fires the WhatsApp notification itself. Nobody has to remember, and the customer hears it from the brand before they have to ask.

Sessions spiked, conversion rate cratered, and the dashboards said the store had suddenly got worse. It hadn't — automated traffic was flooding it. The real damage wasn't the analytics, it was that every retargeting audience was being built from bots, so ad spend was chasing impressions that could never buy.

I isolated the source, applied edge-level controls that blocked it without touching legitimate search crawlers, and then rebuilt the contaminated audiences from clean data. Restoring attribution accuracy mattered as much as stopping the traffic: until the pools were rebuilt, every optimisation decision downstream was being made on poisoned numbers.

Foxify, GemPages and PageFly had all been installed and uninstalled before I arrived, and each one left its files behind in the theme — around 78 sections, snippets and assets that nothing rendered but that every developer after me would have to read and be uncertain about. I traced every file to confirm nothing referenced it, then produced a verified delete list.

Worth being honest about the ending: the Admin API blocks file deletion, so the removal itself is a manual pass in the theme editor rather than something I could script. Half of theme maintenance is knowing exactly which files are safe to delete; the deleting is the easy part.

The question from leadership was which lines to expand. I pulled 18 months of order data against the catalogue and split it by sourcing — made in the Dubai workshop versus imported — and normalised it per SKU, because raw revenue just tells you which category is biggest.

Locally made SKUs were generating 3.2× the revenue per SKU of imported lines. That's a production and catalogue decision, not a marketing one, and it's the kind of answer you only get when the person reading the data also knows how the catalogue is structured and where it lies to you.

Weekly reporting used to be four dashboards, four exports and an afternoon of reconciling numbers that didn't agree. I connected Shopify, Search Console, Klaviyo and Meta Ads through MCP servers so the whole stack can be queried conversationally, and built a catalogue report tool that pulls products, images and performance into one reviewable artifact for merchandising decisions.

This isn't AI as a novelty. It's the difference between "I'll have that by Thursday" and answering the question while the meeting is still happening.

Every bit of customisation on the storefront — fabric choice, custom length, made-to-order acknowledgement — is worthless if it doesn't reach the floor. The Order Printer templates are rebuilt so line-item properties print clearly on the workshop's paperwork, in the order the people building it actually read. Storefront features that don't survive the trip to operations aren't features, they're demos.

A rebuild that went all the way down — information architecture, navigation, product templates, cart and checkout — on a live store that had to keep selling throughout. It lifted conversion to category-leading levels for home and lifestyle and underpinned the growth from AED 600K to AED 3M.

Two habits came out of that job and stayed. First, page speed is a merchandising decision: I stripped legacy app code left behind by previous installs and reworked image and script delivery. Second, document the theme — component usage, conventions, deployment steps — so contractors can work on it safely. I also reviewed contractor code before it deployed, which is where most theme rot actually enters a store.

Every seasonal campaign was a bespoke page, which meant every campaign had a lead time and every page aged differently. I replaced them with dynamic, data-driven templates: pick the collection, set the copy, launch. Klaviyo capture was built into the template rather than bolted on per page, which is where the 35% lift in email signups came from — the form went from being remembered sometimes to existing by default.

Most loyalty programmes fail quietly because they live in a floating widget nobody opens. This one was built into the storefront with account-level logic and redemption displayed where customers were already looking, and it lifted repeat customer revenue. Rewards that customers can't see are just a liability on the balance sheet.

Alongside the web store there were native iOS and Android apps and a set of marketplace channels. Feeding the same catalogue into all of them badly is the standard mistake — each platform ranks differently and buyers arrive with different expectations, so titles, imagery, attributes and pricing were adapted per channel, along with Google Shopping and Meta catalogue feed management.