Keep the Catalog Fast and Cacheable
Catalog traffic is overwhelmingly read-only and highly repetitive, which makes it ideal for caching at several layers. Render product and category pages statically or with incremental regeneration, serve them from a CDN, and keep personalised fragments in separate requests. A product page that varies by user cannot be cached at the edge, so move the personalisation to a small client-side or edge function that composes around a cached shell.
Model the catalog so invalidation is possible. Tag cache entries with category, brand, and collection identifiers on write, then purge by tag when a product changes rather than flushing the whole cache. A launch that clears everything sends every shopper to the origin at the same second, which is the failure mode that turns a successful marketing campaign into an outage. Invalidate only the pages that reference the changed product, never the whole category tree.
Model Cart and Checkout as Separate Concerns
Carts are long-lived, mutable, and tolerant of eventual consistency. Checkout is short-lived, sequential, and intolerant of it. Keep them apart. Store carts in a fast key-value store with a time to live and merge anonymous carts on login. Represent checkout as an explicit state machine: basket validated, shipping selected, payment authorised, order created, confirmation sent, each transition persisted with an idempotency key. Persist every transition so a failed payment can resume from the last confirmed step instead of restarting the basket.
Reserve stock at the start of checkout with an expiry, and release it if payment fails or the session is abandoned. Never decrement inventory on page view. Confirm the order exactly once using the idempotency key, because payment providers retry webhooks and users double-click. A duplicate order costs more trust than a slow page ever will. Hold the reservation in a single transaction so two requests cannot both claim the last unit.
- Idempotency key on every checkout transition.
- Inventory reservation with a ten-minute expiry.
- Webhook handlers that tolerate duplicate delivery.
- An order ledger that records the source of every state change.
Survive Launches with Queueing and Backpressure
Traffic spikes are predictable and still break systems. Put a queue between the storefront and the work that can be deferred: order confirmation emails, warehouse notifications, analytics events, loyalty updates. The synchronous path should do only what the customer must wait for. When the queue deepens, shed or defer low-priority work instead of letting the checkout thread pool saturate. Give each deferred job a priority and a retry budget so a flood of low-value work cannot delay order confirmations.
Set explicit limits and test them. A connection pool of twenty with a two-second acquisition timeout behaves predictably under load, while an unbounded pool collapses the database and the application together. Add circuit breakers around payment and tax providers with a cached fallback, and load-test the whole path at two times the projected peak before a major campaign goes live. Record why each request was shed so support can explain an incomplete order to the customer.
Cache and Paginate with an Invalidation Strategy
Pagination at scale means keyset, not offset. A catalog with a million products cannot afford an offset query on page four hundred, and the result shifts as inventory changes. Use the last sort key as the cursor, encode it opaquely, and return a next-cursor alongside the page. Combine it with a short cache keyed on the cursor and the active facets, then invalidate facet counters when a product availability changes.
Define cache lifetimes by data volatility: product copy in hours, price in minutes, stock in seconds. Stale prices are a legal problem, stale stock is a support problem, stale marketing copy is only cosmetic. Stamp every cached payload with the version it was built from so a debugging session can confirm which rules produced a page. Review those lifetimes whenever a new integration starts writing price or stock directly.
// Tag-based invalidation around a cached catalog read.
const key = `catalog:${tenant}:${cursor ?? "start"}`;
const cached = await cache.get(key);
if (cached) return cached;
const page = await db.products.byKeyset(cursor, 48);
await cache.set(key, page, { ttl: 60, tags: ["catalog", ...page.facets] });
return page;Instrument the Funnel and the Edge
Measure conversion at each step from product view to payment success, segmented by device, geography, and campaign. A drop in add-to-cart points at merchandising or performance; a drop at payment points at trust or integration. Track Core Web Vitals in the field rather than in a lab, because a fast staging environment hides the mobile network that half the customers actually use.
Alert on symptoms customers feel, not only on CPU: error rate on the checkout route, p75 largest contentful paint on product pages, queue depth, and payment provider latency. Rehearse peak traffic and a degraded payment provider in the same game day. Scalability is not a single benchmark result but the demonstrated ability to absorb a bad afternoon without losing orders.