ShopEase Platform

Production-Grade Microservices · Polyglot Persistence · 5-Layer Test Pyramid · Full Observability

🟢 Live in Production 4 Services | 330+ Tests | 85%+ Coverage | ~5 min Deploy Request Live Access GitHub ↗

Overview

ShopEase is a full-stack, cloud-native eCommerce platform built to production standards. Every service is independently deployable, domain-modelled behind a bounded context, continuously integrated via a five-layer test pyramid, and instrumented end-to-end with OpenTelemetry auto-instrumentation. The platform runs on Kubernetes with GitOps deployment and zero-trust network policies.

This is not a tutorial project — it is a living, deployed system demonstrating enterprise engineering patterns that are often described but rarely shown together in a single repository.

Architecture Diagram

Platform Structure

┌──────────────────────────────────────────────────────────────────┐
│               Cloudflare Tunnel + Access                         │
│               shop.kunlecreates.org                              │
└────────────────────────┬─────────────────────────────────────────┘
                         │
┌────────────────────────▼─────────────────────────────────────────┐
│                  NGINX Ingress Controller                        │
│           (TLS termination, path-based routing)                  │
└──────┬──────────────┬──────────────┬──────────────┬──────────────┘
       │              │              │              │
  /frontend      /api/user      /api/products   /api/orders
       │              │              │              │
  ┌─────────┐  ┌──────────┐  ┌─────────┐   ┌─────────────┐
  │frontend │  │user-svc  │  │product  │   │order-service│
  │Next.js  │  │Java 21   │  │NestJS   │   │Java 21      │
  │         │  │Spring    │  │Node.js  │   │Spring Boot  │
  │         │  │Oracle DB │  │Postgres │   │MS SQL Server│
  └─────────┘  └──────────┘  └─────────┘   └──────┬──────┘
                                                   │ async notify
                                             ┌─────▼───────┐
                                             │notif-service│
                                             │Python 3.12  │
                                             │FastAPI/SMTP │
                                             └─────────────┘

Service Breakdown

🔐 user-service Java 21 Spring Boot 3 Oracle DB 23c

Full identity & auth domain: registration, JWT/RS256, email verification, password reset, RBAC (CUSTOMER/ADMIN), and login audit logging. Every token value is stored as a bcrypt hash — plaintext secrets never persist.

🏷️ product-service Node.js 20 NestJS 10 PostgreSQL 17

Product catalogue, full-text search (TSVECTOR), inventory tracking, and stock movement audit. Prices stored as integer cents (no floating-point). JSONB attributes column handles flexible per-SKU metadata without schema migrations.

🛒 order-service Java 21 Spring Boot 3 MS SQL Server 2022

Cart lifecycle (OPEN → CHECKED_OUT → ABANDONED), order management, payment metadata. Shipping address snapshotted at checkout — historical orders are immutable. Only display-safe payment metadata stored (PCI scope reduction).

📧 notification-service Python 3.12 FastAPI Stateless

Stateless email dispatcher. Consumes order events, renders Jinja2 templates, dispatches confirmation emails via SMTP. No database — trivially scalable and independently testable. Async call from order-service post-checkout.

Test Pyramid (330+ Tests)

Layer	Location	Tools	Blocks PR?	Tests
Unit	`services/*/test/`	JUnit 5, Jest, pytest	✅ Yes	277
Frontend Unit	`frontend/__tests__/`	Jest	✅ Yes	53
Integration	`services/*/test/integration/`	Testcontainers (real DBs)	✅ Yes	~40
API Contracts	`api-tests/`	Supertest, RestAssured	✅ Post-deploy	18 files
E2E	`e2e/`	Playwright	❌ Monitoring	7 spec files

CI/CD Pipeline

GitHub Actions → GHCR → Kubernetes Helm deploy. All five services build in parallel. Total time from git push to live deployment: ~5 minutes.

📊

Coverage Authority Workflow — Platform-Level Quality Visibility

The Coverage Authority is a dedicated GitHub Actions workflow that runs after all five service CI pipelines complete. It collects the per-service coverage artefacts, computes a weighted aggregate across the entire platform (∼85%+ current), and auto-publishes the updated badge to the coverage-badge branch on every push. This is not per-service coverage tracking — it is a cross-platform signal that treats quality as a platform-level concern. A single service dropping below threshold fails the aggregate gate and alerts the team before any deployment proceeds.

1️⃣ All 5 service CIs run in parallel 2️⃣ Coverage Authority workflow triggers on completion 3️⃣ Artefacts aggregated across Java, Node.js & Python 4️⃣ Weighted aggregate computed 5️⃣ Badge auto-updated on coverage-badge branch 6️⃣ README badge reflects live state on every push

Fail fast: Unit tests precede integration tests in every pipeline
Real databases in CI: Testcontainers prevents environment-specific failures
Build once, deploy everywhere: The CI image is the exact production image
Self-hosted ARC runner: GitHub Actions Runner Controller running on-cluster

Observability Stack

OpenTelemetry Operator auto-injects agents — no SDK changes required in application code.

📊 Prometheus + Grafana — HTTP metrics, JVM heap, GC pauses, connection pool utilisation
🔍 Jaeger v2 — Full distributed traces across all services with per-span timing
📝 Elasticsearch + Kibana (ECK) — Centrally aggregated, indexed, and searchable logs
⚙️ OTel Operator — Auto-instrumentation for Java, Node.js, and Python services (40–60% overhead optimised)

Security Architecture

JWT/RS256 — Asymmetric token signing; public key distributed to verifying services
Bcrypt (cost 12) — Passwords and all token values stored as hashes only
HttpOnly cookies — JWT storage; eliminates XSS token theft via JavaScript
Zero-trust NetworkPolicies — Deny all by default; explicit per-service ingress/egress rules
Least-privilege DB users — App connects as CRUD-only role; no DDL rights at runtime
Email verification — Required before full account access; tokens single-use and time-limited
OWASP Top 10 — Parameterised queries, CSP headers, CSRF protection, rate limiting via NGINX

Polyglot Persistence

Service	Engine	Why This Engine
user-service	Oracle DB 23c Free	Complex relational auth domain. JSON constraint (`IS JSON`) for domain event outbox. Enterprise audit capability.
product-service	PostgreSQL 17	Native `TSVECTOR` full-text search. `JSONB` for flexible product attributes. Best-in-class ORM support for NestJS.
order-service	MS SQL Server 2022	Schema isolation via `order_svc` schema qualifier. Strong typing for financial transactions. Spring Data JPA + MSSQL Testcontainers.

UI Walkthrough (GIF Preview)

End-to-end user journey through the ShopEase web application — registration, product browsing, cart management, and order placement.

I wrote detailed engineering deep dives covering this platform:

Architecture Deep Dive — All 6 Engineering Pillars →

Database-as-a-Service Engineering Deep Dive →

Contact

The source code is public on GitHub. For a walkthrough of any specific service, the CI/CD pipeline configuration, or the Kubernetes manifests, contact me directly.