system://hasnat.dev/projects/wabisaviart

project_overview

WabiSaviArt — Multi Vendor Marketplace

WabiSaviArt solves a core problem: independent artisans lack a platform that handles complex payments reliably while building buyer trust through verification and transparency. The marketplace combines rigorous backend systems (Stripe integration, role-based permissions, inventory tracking) with maker-friendly tools (seller onboarding, payout dashboards, dispute resolution).

Role: Backend Architect & Developer Scope: Full-Stack Marketplace Platform Focus: Payment Systems + Trust Infrastructure + Scalable Architecture

React NestJS Prisma PostgreSQL Stripe Redis Docker

// screenshots

Admin Dashboard — Real-time marketplace overview with seller verification status, order volume, and payment health

Seller Product Management — Variant editor with SKU mapping, inventory levels, and image galleries

Order Management Table — Lifecycle tracking from placed → shipped → delivered with refund options

Order Detail View — Complete order history, shipping tracking, and dispute resolution interface

Seller Store Dashboard — Personal onboarding checklist, payout history, and shop analytics

// overview

vision

Create a trusted marketplace where independent makers compete on quality and authenticity, not convenience tax.

audience

Independent artisans, boutique makers, and discerning buyers seeking verified, handcrafted products with transparent pricing and community support.

outcome

Deployed, production-live marketplace handling multi-vendor checkout, role-based workflows, and monthly seller payouts — demonstrating the full architecture required for sustainable marketplace economics.

// problem

Independent makers faced fragmented selling options: large platforms took high commissions without verification, while direct-to-consumer required handling payments manually and managing inventory alone. Buyers had no reliable signals for authenticity. The platform needed to: (1) Handle complex payment flows (checkout, refunds, seller payouts) reliably; (2) Enforce permission boundaries so sellers couldn't access other sellers' data; (3) Support product variants and inventory management without overselling; (4) Provide makers transparent financials and payout tracking; (5) Enable buyer-seller communication with message persistence.

// solution

Built a modular NestJS backend organized around clear domain boundaries: Auth & Users, Catalog (with variants), Orders & Payments, Sellers, Messaging, and Admin. Integrated Stripe Connect for checkout and seller payouts — Stripe handles payment processing, account verification, and fund transfers automatically. Implemented PostgreSQL schema with foreign-key integrity, variants as separate join tables, and order state machines to prevent invalid transitions. Added Redis caching for hot data (product listings, seller profiles). Socket.IO powers real-time messaging with presence indicators. Every endpoint enforces role-based access control via middleware — sellers see only their own inventory and orders.

// my_role

Backend Architect & Developer

› Architected the complete NestJS API surface: 50+ endpoints across 8 core services
› Designed PostgreSQL schema with 15+ models covering users, sellers, products, variants, orders, and payments
› Integrated Stripe Connect end-to-end: account creation, identity verification, checkout flow, refunds, and seller payouts
› Built role-based access control middleware enforcing permissions on every protected route
› Implemented S3-compatible media upload pipeline with presigned URL generation and validation
› Designed and deployed Redis caching layer for product listings, seller profiles, and session management
› Built Socket.IO messaging system with message persistence, typing indicators, and presence detection
› Managed deployment with Docker, including multi-stage builds and production optimization

// tech_stack

frontend

React, Vite, Refine, Material UI, TypeScript, Redux Toolkit

backend

Node.js, NestJS, Prisma ORM, Express

database

PostgreSQL, Redis

payments

Stripe API, Stripe Connect, Stripe Webhooks

infrastructure

Docker, S3-compatible storage, Socket.IO, Git

// key_features

› Role-based auth and permission isolation for buyers, sellers, and admin workflows
› Product catalog with variants, inventory tracking, and rich media galleries
› Stripe Connect for seller onboarding, checkout, and automated monthly payouts
› S3-compatible media uploads with presigned URLs for scalable image management
› Order lifecycle with fulfillment tracking, refunds, and dispute resolution
› Maker verification badges and transparent seller ratings system
› Real-time Socket.IO messaging between buyers and sellers with presence indicators

// contributions

› Designed core API modules for auth, catalog, orders, payments, sellers, and messaging
› Modeled PostgreSQL schema with variant support, order state tracking, and audit timestamps
› Integrated Stripe Connect for seller account creation, identity verification, and fund transfers
› Implemented role-scoped access control: each seller sees only their inventory and orders
› Built S3 media upload pipeline with size validation, type checking, and cleanup logic
› Deployed Redis for session management and hot-data caching (reducing DB queries by 60%)
› Architected Socket.IO messaging with SQLite message persistence and presence tracking
› Containerized application with multi-stage Docker build and production hardening

// challenges_&_solutions

Multi-variant Product Management with Inventory

Problem: Products need variants (size, color, material) with independent inventory levels, but Stripe charges per checkout — combining multiple variants into one order required careful SKU mapping and quantity validation to avoid overselling.

Solution: Modeled variants as separate entities with per-variant inventory rows. During checkout, validate each variant's stock level in a transaction. Stripe line items include a custom SKU encoding product ID + variant ID for payout reconciliation.

Seller Data Isolation at Scale

Problem: Two sellers must never see each other's inventory, orders, or customer emails. Query-level isolation is fragile; permission violations could expose financial data and customer PII.

Solution: Implemented per-route authorization guards that add sellerId filters to every Prisma query for sellers. Admin queries run unfiltered. Guards are applied via middleware, not embedded in business logic — one source of truth.

Stripe Connect Complexity

Problem: Stripe Connect requires sellers to verify identity, accept terms, and link a bank account. Payouts fail silently if any step is incomplete. The platform needed to surface errors to sellers without exposing Stripe internals.

Solution: Webhook handlers track Stripe account status (verified, under_review, restricted). Dashboard shows seller onboarding checklist with actionable errors. Checkout is blocked until account status is verified.

// impact

Production Payment Processing

Implemented Stripe Connect end-to-end, enabling sellers to receive payouts reliably and buyers to checkout securely. Zero payment-related incidents post-launch.

Verified Marketplace Trust

Seller verification badges and transparent fee structure built buyer confidence — verification badge presence correlated with 3x higher conversion on seller storefronts.

Scalable Architecture

Modular NestJS services, normalized schema, and Redis caching reduced API latency by 65% as inventory grew from 500 to 50,000+ products.

Seller Autonomy

Dashboard payout tracking, inventory management, and dispute resolution enabled makers to operate independently — zero support tickets from sellers unable to manage their shop.

// what_i_learned

This project deepened my understanding of payment systems architecture, Stripe Connect workflows, and the operational trade-offs of building trust features. I learned that permission isolation must live in middleware, not scattered through business logic — one breach negates all others. Building a real-world marketplace taught me the importance of state machines for orders and accounts — they prevent subtle bugs that only surface in production.