Saksham Jain
Back to work
/ 05Case study2026

Skyxis

D2C e-commerce storefront for premium wireless audio — product catalog, cart, wishlist, quick view, and checkout across headphones, earbuds, and accessories.

E-CommerceD2CFull-StackNext.js
Visit Skyxis
Skyxis homepage hero showing the Skyxis Pulse wireless headphones product shot.
Role
Full-stack Developer
Focus
Catalog, cart & checkout
Year
2026
Status
Production

Overview

Skyxis is a direct-to-consumer e-commerce storefront for premium wireless audio — headphones, earbuds, and accessories. The site covers the full retail loop: category and product browsing, quick view, wishlist, cart, and checkout, with featured, deals, and new-arrivals rails pulling from the same product catalog.

My role

I worked as a full-stack developer on Skyxis, building the product catalog and category browsing, the cart and wishlist (for both guest and logged-in shoppers), and the checkout flow through to order confirmation. Most of the actual complexity sat in keeping cart state, stock, and price consistent across a guest session, checkout, and payment.

The complexity

Problem — A guest's cart and wishlist need to survive a page refresh, then merge cleanly into their account the instant they log in — without silently dropping items from either side.

Approach — Cart and wishlist persist client-side for guests and merge into the server-side cart on login as a union of both, not an overwrite, so nothing gets lost in either direction.

Problem — "In Stock" and "Only N left" badges are read at listing time, but inventory can change by the time someone reaches checkout — a stale badge shouldn't let someone pay for something that's already gone, and with a wide catalog checking out concurrently, holding a database lock per checkout doesn't scale the way it does on a single hot event.

Approach — Inventory is re-checked at checkout with optimistic locking — a version field on the stock row — rather than trusted from the listing page or held behind a pessimistic lock: went optimistic here, not pessimistic like a single flash-sale item, because carts across hundreds of different SKUs rarely contend for the same row, so a lock held for the checkout window would cost more than the rare retry does. Holds correct under 100+ concurrent checkouts across the catalog.

Problem — Price, discount percentage, and active promo codes need to agree across listing, cart, and checkout — a client-computed price drifts the moment a promo or discount changes, and recomputing pricing from MongoDB on every listing page view adds latency for data that changes rarely.

Approach — Pricing is computed server-side (base price, discount, active promo) and cached in Redis in front of the catalog, invalidated the moment a price or stock level changes, so listing pages stay fast without ever serving a price the client had to calculate itself.

Problem — Doing order confirmation, inventory write-down, and the email receipt inline in the checkout request makes the customer wait on work that isn't their payment.

Approach — Checkout publishes an "order placed" event to RabbitMQ the moment payment clears and returns immediately; a fulfillment consumer handles the email and downstream bookkeeping, so checkout latency isn't tied to how long the email provider takes to respond.

Architecture

Cart to checkout
Product listing
Redis-cached catalog
Cart / wishlist
Guest, merges on login
Checkout
Inventory recheck
Optimistic lock, versioned
Payment gateway
RabbitMQ
Fulfillment + email
Pricing consistency
Base price + discount + promo
Server-owned
Pricing engine
Cached in Redis
Listing
Cart
Checkout
Same computed price, every screen

What shipped

  • Product catalog with category browsing, quick view, and wishlist.
  • Guest cart with login-time merge into the account cart.
  • Checkout with server-side inventory recheck and centralized pricing.
  • Featured, deals, and new-arrivals rails driven by the same product API.

What I owned

API & data model
Server-side pricing engine (base price, discount, promo) and the guest-to-account cart/wishlist merge logic.
Infrastructure
Redis cache in front of the product catalog, and a RabbitMQ queue driving order fulfillment after payment.
Integrations
Payment gateway checkout with an inventory recheck gating it, not a trust-the-listing-page shortcut.
Frontend
Product catalog, category browsing, quick view, cart, wishlist, and checkout through to confirmation.

Engineering properties

  • Guest cart merges into account cart on login, no data loss
  • Optimistic locking on stock, retries instead of blocking
  • Redis-cached catalog, invalidated on price/stock change
  • RabbitMQ decouples order fulfillment from checkout

Stack

Next.jsNode.jsExpressMongoDBRedisRabbitMQPayment Gateway