Skip to content
aviral gupta

// SERVICE 09 — E-COMMERCE

E-commerce built so the catalogue ranks and the checkout converts.

Transaction-grade storefront services built for catalogue crawl efficiency and checkout integrity. Idempotent order orchestration layers, regional payment gateway webhooks across multiple providers, and distributed data layers that reconcile with backend systems.

✓ payment gateways: N-Genius, Adyen · ✓ 326 SEO pages shipped for Cariva · ✓ 6 production microservices

Architectural focus
Transactional correctness: checkout and booking state, idempotent webhooks, reconciliation
System benchmark
Deployed storefront with a live, reconciled checkout
Verification gates
Vitest suites over order state transitions, purchase event QA, schema validation

Full service list

// TECHNICAL OWNERSHIP

What does a production e-commerce build actually include?

Catalogue and product data model

Products, variants, options, inventory and pricing modelled once, then served to storefront, feeds and schema from the same source, so nothing drifts between channels.

Services that hold the catalogue

Catalogue, pricing, order and payment concerns split into services that deploy and scale separately, the shape of the six Node.js microservices I ran in production serving two brands at once.

Checkout that survives real traffic

Cart persistence, guest checkout, address and VAT handling, error states, and idempotent order creation so a double-tapped pay button never produces two charges or two orders.

Payment gateway integration

N-Genius, Adyen, Bank of Muscat and PointsPay, wired with webhooks, 3-D Secure, refunds and reconciliation, plus honest advice on onboarding times before you commit.

Product and Offer schema

Product, Offer, BreadcrumbList and ItemList emitted from live catalogue data and validated in Rich Results, so listings stay accurate as stock, variants and pricing change.

Faceted navigation crawl control

Filter and sort combinations generate near-infinite URLs. I decide which facets get indexable routes, which get canonicals or noindex, and which are blocked before crawl budget disappears.

Revenue tracking that reconciles

GA4 ecommerce events, Meta Pixel with Conversions API and deduplication, server-side purchase events, so the number in your ad platform matches the number in your order table.

Performance budgets on PDP and PLP

Category and product templates built to LCP under 2.5s and CLS of zero, with image pipelines and lazy hydration tuned for long listing pages on mobile networks.

// PROCESS

How does it work?

  1. 1

    Commercial discovery

    A working session on catalogue size, margins, markets and fulfilment, so the platform decision is made on your economics, not my preference.

  2. 2

    Architecture decision, in writing

    A short written comparison of the realistic options for your case: rendering strategy, service boundaries, costs of change, ownership and the risks of each.

  3. 3

    Blueprint

    Data model, URL and facet architecture, schema map, tracking plan and gateway choice signed off before a single template is designed.

  4. 4

    Build and test transactions

    Weekly staging demos, real test orders through the gateway sandbox, refund and failure paths exercised, performance budgets enforced on every deploy.

  5. 5

    Launch and watch the money

    Cutover with redirects if you are replatforming, then thirty days watching indexation, Core Web Vitals and purchase-event accuracy, reported weekly in writing.

// PROOF

Where have I run this in production?

Cariva, a UAE car sales and used-car platform, is the closest thing to this build I have shipped: a Next.js front end over six Node.js microservices, 326 templated SEO pages, including 149 model, 100 used-car and 65 brand, payment gateways including N-Genius, and a full GA4, GTM and Meta Pixel layer. Same problems as a catalogue store — templated pages at scale, transactional checkout, money that has to reconcile. At Thrifty I later built an abandoned-booking recovery module on the same kind of data layer.

326 SEO pages6 microservicesN-Genius in productionRecovery module = new revenue

Read the full case study

// TOOL STACK

Which tools do I reach for?

Next.jsReactTypeScriptNode.jsMongoDBExpressN-GeniusAdyenNetwork InternationalGA4Meta CAPIScreaming FrogLighthouse CISearch Console

The technologies and tools behind the work.

// FAQ

What should you know about how I work on this?

By your economics, not my preference. Catalogue size decides how much of the store can be generated at build time and how much has to stay dynamic. Traffic shape decides where caching sits. Subscriptions, complex pricing, B2B rules and unusual fulfilment decide where the service boundaries go. I write that comparison down, including costs of change, ownership and integration risk, before anything is designed, so you can disagree with it.

You do, in full, from the first commit. Code lives in your repository, deploys from your hosting account, and connects to gateway and analytics accounts in your name. There is no licence, no hosting lock-in and no agency-owned wrapper. If you decide to move to another developer, you hand over access and everything keeps working. That is the test I build against.

The four I have integrated in production are N-Genius, Adyen, Bank of Muscat and PointsPay, all on the same booking flow. For a UAE store N-Genius and Adyen are the usual pair. Elsewhere the provider changes but the integration work does not. The integration matters more than the logo: webhooks, 3-D Secure, refunds, idempotency and reconciliation. I also flag onboarding times early, because merchant approval takes days with some providers and weeks with others, and that timing shapes your launch date.

That is the default requirement, not an extra. I crawl every existing URL (products, categories, filtered pages, discontinued lines) and map each one to its destination before rebuilding starts. Metadata, canonicals and Product schema carry over or improve deliberately. I did exactly this on Thrifty's PHP Laravel to Next.js migration in the UAE with no ranking drop, and the same playbook applies to a catalogue.

Six to twelve weeks from signed scope to live checkout, depending on catalogue size, number of integrations and how ready your product data is. Discovery and the platform decision take the first week. You see a staging URL every week after that, so progress is visible rather than reported. Gateway merchant approval runs in parallel, because it is usually the longest external dependency.

Thirty days of monitoring are included: indexation, Core Web Vitals, gateway errors and purchase-event accuracy, reported weekly in writing. Stores break in specific ways — a failed webhook, a schema field that stops validating, a filter page that starts getting indexed — so the watch window is aimed at those. Beyond thirty days, optional ongoing support keeps the same checks running.

Often. I am one developer, not an agency, so I slot into your workflow rather than replacing it: your repository, your branch strategy, your ticket board, your review process. A common split is that I own storefront, checkout, schema and tracking while your team keeps the backend or ERP integration.

// OPEN TO WORK

Building a storefront, or replatforming one?