E-commerceStarter KitBusiness

Marketplace Starter Kit for Boutique Manufacturers (Order + Wholesale)

rreactnative

2026-02-15

10 min read

Bootstrap a marketplace for boutique manufacturers: catalog, subscriptions, wholesale pricing, shipping & payments—React Native focused.

Bootstrap a Marketplace Starter Kit for Boutique Manufacturers in 2026

Hook: If you build small-batch products (think Liber & Co.-style craft syrups) and you need one app to sell direct to consumers and handle wholesale accounts, subscriptions, shipping, and payments—without a 6‑month rewrite—this starter kit blueprint is for you.

Small producers face the same constraints in 2026 as they did a decade ago: limited engineering budget, must-move-fast product cycles, and the need to serve both B2C and B2B customers with distinct UX, pricing, and fulfillment rules. This article gives a pragmatic, code-first blueprint for a Marketplace Starter Kit that ships a catalog, subscriptions, wholesale pricing, and shipping integration—built with React Native as the mobile client.

What you’ll get (most important first)

A recommended 2026 architecture (React Native + headless commerce + serverless) optimized for speed and maintainability.
Concrete data models for catalog, subscriptions, wholesale tiers, and shipping.
Integration patterns for payments (Stripe Connect + Billing), tax (Stripe Tax / TaxJar), and shipping (EasyPost / Shippo).
React Native implementation tips: Expo vs bare workflow, list performance, offline sync, and a copyable product-list component.
Operational checklist and a 90-day roadmap to get a boutique manufacturer selling B2C and B2B fast.

Why 2026 is the right moment

Late 2025 and early 2026 reinforced two trends that matter for this starter kit:

Headless & composable commerce matured: open-source headless platforms and marketplaces (Medusa, Saleor, Commerce.js, and managed variants) eliminated the need to build cart, pricing, and subscription plumbing from scratch.
Mobile-first stacks stabilized: React Native and Expo continue to reduce friction for building performant native apps with predictable CI/CD via EAS and improved Hermes support for small teams.

“We learned to do everything ourselves—from manufacturing to ecommerce.” — Liber & Co.: a real-world example of a boutique brand scaling DTC and wholesale while keeping a DIY culture.

Starter Kit architecture (high level)

Design for separation of concerns: keep the mobile client thin, delegate business logic to headless commerce or serverless functions, and use managed services for payments, tax, and shipping.

Recommended stack

Mobile: React Native (Expo Managed for rapid delivery; Bare for native modules)
Backend: Headless commerce (Medusa or Saleor) or commerce platform (Shopify Hydrogen storefront or Commerce.js) + Node.js serverless functions (Vercel / Netlify)
Payments & Subscriptions: Stripe Billing + Connect (or Adyen for enterprise), Stripe Tax for automated tax calculation — see common checkout flow patterns.
Shipping & Labels: EasyPost or Shippo for carrier rates, label purchase, and tracking webhooks — consider local pickup patterns from neighborhood market strategies.
Inventory & ERP sync: lightweight Postgres + Redis; integrate QuickBooks / Xero via Zapier or direct API
CI/CD: GitHub Actions + EAS Build (Expo) or Fastlane (bare RN) — pair this with a small dev workstation setup (see compact dev kits review).

Core features—and how to implement them

Below are the features every boutique marketplace needs, plus actionable implementation notes.

1) Catalog: data model & synchronization

Keep a canonical product model in your headless backend and expose a compact API to mobile clients.

Product model (suggested fields)

id, sku, title, slug
description (markdown or rich text)
images: CDN URLs and variants (webp/heif)
price (retail), price_wholesale (per-tier), currency
inventory_count, inventory_location_ids
tags, categories, physical_attributes (weight, dims)
subscription_options (interval, trial_days)

Actionable: add an incremental sync endpoint for the mobile app that returns a timestamped delta (created/updated/deleted). This keeps the app responsive and reduces bandwidth.

2) Subscriptions: handling recurring billing

Leverage Stripe Billing to avoid reinventing proration, trials, dunning, and invoices. Use the server to create Stripe Products and Price objects and return client-only checkout sessions or PaymentIntents.

// Example: create subscription session (Node.js serverless)
const stripe = require('stripe')(process.env.STRIPE_KEY);
module.exports = async (req, res) => {
  const { customerId, priceId } = req.body;
  const session = await stripe.checkout.sessions.create({
    mode: 'subscription',
    customer: customerId,
    line_items: [{ price: priceId, quantity: 1 }],
    success_url: process.env.SUCCESS_URL,
    cancel_url: process.env.CANCEL_URL,
  });
  res.json({ sessionId: session.id });
};

Tip: For B2B subscriptions (recurring wholesale shipments), expose net-terms and invoice generation via Stripe Invoicing or custom invoicing that integrates with your accounting system. For contract notifications and PO approvals, consider more reliable mobile channels like RCS and secure mobile channels.

3) Wholesale pricing & B2B flows

Wholesale is not just a discount—it's a different UX: account approvals, minimum order quantities, purchase orders, invoices, and sometimes separate shipping rules.

Essential wholesale components

Role-based accounts: consumer, wholesale_buyer, sales_rep
Pricing rules: tiered pricing (volume breaks), customer-specific price overrides
Approval workflow: sellers review KYC documents and approve accounts programmatically
POs & Net terms: allow PO upload, generate invoice PDFs, and set net-30/60 terms

Actionable: implement a server-side price resolution function. Mobile clients request final line-item prices from the server at checkout to avoid client-side manipulation.

// Pseudocode: price resolution
function resolvePrice(productId, customerId, qty) {
  const product = db.getProduct(productId);
  const customer = db.getCustomer(customerId);
  if (customer.type === 'wholesale') {
    return getWholesalePrice(productId, qty, customer.tier);
  }
  return product.price;
}

4) Checkout & payments

Two simultaneous flows: B2C (instant card checkout) and B2B (PO/invoice/net terms). Use a unified order object but different fulfillment/payment states.

B2C: Stripe Checkout or Payment Intents for cards, wallets (Apple Pay / Google Pay), and BNPL (Affirm/Afterpay).
B2B: accept purchase orders; optionally collect a deposit via Stripe or set invoices with Stripe Billing & Invoicing.
Split payments: if your marketplace takes fees or there are multiple sellers per order, use Stripe Connect to route funds.

5) Shipping integration & fulfillment

Use EasyPost/Shippo to fetch carrier rates, purchase labels, and track shipments. Add shipping rules for wholesale (e.g., pallet vs parcel) and per-location inventory.

Practical integration tips

Calculate real-time rates at checkout using package weight and dimensions.
Offer pickup and local delivery for nearby wholesale customers; integrate with last-mile couriers via API.
Automate label creation and send the PDF/PNG to your warehouse printer or fulfillment partner.
Expose shipment tracking in the mobile app and web portal using carrier webhooks.

React Native implementation patterns

Design the mobile client to be resilient: fast lists, image caching, offline mode for order capture, and low-latency checkout UX.

Expo vs Bare

Expo Managed: fastest path for small teams—EAS supports background tasks, push, and builds. Choose Expo if you don’t need complex native modules for label printers or custom BLE devices.
Bare RN: required when integrating heavy native SDKs (carrier SDKs, thermal printer SDKs). Keep the app modular to allow swap between managed and bare later.

Performance: lists, images, hydration

Use FlashList (Shopify’s performant list) or RecyclerListView for product lists of thousands of items.
Use react-native-fast-image or platform-optimized image components and serve images from a CDN (Cloudflare/Cloudinary).
Keep initial bundle small; lazy-load feature screens like Admin or Wholesale order entry.

// Simple product list component (copyable)
import React from 'react';
import { View, Text, Image, TouchableOpacity } from 'react-native';
import { FlashList } from '@shopify/flash-list';

export default function ProductList({ products, onSelect }) {
  return (
     (
         onSelect(item)}>
          
            
            
              {item.title}
              {item.price}
            
          
        
      )}
    />
  );
}

Offline-first & order capture

Field sales reps and farmers’ markets need offline order capture. Use SQLite (react-native-sqlite-storage) or WatermelonDB to persist carts and sync when online. Use background sync for uploads — and consider resilient sync patterns from edge message brokers to handle intermittent connectivity.

Authentication & account roles

Implement JWT-based auth with refresh tokens. For wholesale, require KYC document upload and an approval webhook that flips the account role after manual review. Pair PO and invoice flows with secure mobile notifications like RCS and secure mobile channels for better reliability.

Security, compliance & operational safeguards

PCI: Use Stripe-hosted elements or Checkout to minimize PCI scope — see checkout flow patterns for examples.
Data protection: store minimal PII on device and encrypt sensitive fields in the backend. Consider trust frameworks when selecting telemetry vendors (trust scores).
Audit logs: keep server-side logs for order edits, price changes, and manual overrides — tie this into network observability for outages (network observability).
Licensing: vet third-party packages for maintenance and MIT/BSD-compatible licenses to avoid legal friction for a marketplace product.

Maintenance & versioning strategy

React Native compatibility is a persistent concern for small teams. Recommended strategy:

Pin to a long-term tested RN and Expo SDK combo. Track community LTS releases periodically; use small dev kit setups reviewed in the community (compact dev kits).
Automate dependency updates with Renovate and test builds on EAS for each PR.
Modularize native code so updates affect minimal surface area.

Operational playbook for the first 90 days

Deliver value fast. Use this checklist to get a minimal production-ready marketplace running in ~90 days.

Phase 0: Week 0—Discovery

Identify SKUs, wholesale tiers, minimum order quantities, and shipping lanes.
Decide platform: Medusa/Saleor vs Shopify-based headless. Prefer open-source for flexibility.

Phase 1: Weeks 1–3—MVP back end

Implement product model, inventory, and price resolution.
Wire Stripe for payments and Billing for subscriptions.
Set up EasyPost/Shippo and integrate test carriers.

Phase 2: Weeks 4–8—Mobile client & admin

Build product catalog screens, checkout, and subscription flows in React Native (Expo).
Create a lightweight web admin for orders and approvals (Next.js + Vercel).

Phase 3: Weeks 9–12—Testing & launch

End-to-end tests for payments, shipping labels, and wholesale approvals.
Beta with a handful of wholesale customers and iterate on PO workflows and net terms.

Advanced strategies for scaling beyond MVP (2026+)

AI demand forecasting: use lightweight ML to predict restock and reduce spoilage for perishable ingredients — consider learning patterns from applied AI reports.
Micro-fulfillment: local hubs to reduce shipping costs and enable faster B2B deliveries (see neighborhood market approaches).
Omnichannel sync: unify POS, wholesale portal, and mobile app inventory with real-time sync.
Green shipping options: let buyers choose carbon-neutral shipping and surface costs at checkout.

Case study: lessons from Liber & Co. (applied)

Liber & Co. began as a DIY brand that handled manufacturing, warehousing, and ecommerce in-house. The lesson for a starter kit: design for teams that will wear many hats—operations, marketing, and fulfillment.

Make admin tasks simple: bulk uploads, CSV exports for shipments, and quick order edits.
Support both consumer and wholesale channels from day one; small manufacturers often pivot between channels.
Minimize vendor lock-in: prefer modular, replaceable integrations for payments and shipping.

Common pitfalls & how to avoid them

Underestimating wholesale complexity: Don’t treat wholesale as “consumer minus 20%”. Build for POs, M.O.Q.s, and invoices.
Client-side pricing logic: Always resolve final prices server-side to prevent manipulation.
Poor shipping rules: Test real orders (weights/dimensions) to avoid unexpected carrier surcharges.
Ignoring maintenance: schedule quarterly dependency audits and keep E2E tests for critical flows.

Actionable checklist (copy & run)

Choose headless backend: Medusa or Saleor. Deploy test instance in 48 hours.
Wire Stripe: enable Billing & Invoicing and test subscription & invoice flows.
Integrate EasyPost and create a label purchase webhook.
Bootstrap a React Native Expo app and implement the product list (use the FlashList snippet above).
Implement server-side price resolution and a wholesale approval endpoint.
Test a full order flow: cart -> checkout -> label -> tracking -> fulfillment.

Final recommendations

For boutique manufacturers in 2026, the goal is to deliver a predictable, maintainable marketplace that supports both B2C subscriptions and B2B wholesale with minimal friction. Use composable services for payments and shipping, keep business logic on the server, and make the mobile UI fast and resilient.

Takeaways

Start with a headless backend to avoid rework.
Resolve prices server-side and support role-based wholesale flows.
Use Stripe + EasyPost to cover payments, billing, taxes, and shipping quickly.
Choose Expo for rapid mobile delivery unless you need deep native SDKs.
Plan for growth: modular integrations, automated testing, and a clear upgrade path for RN and dependencies.

Call to action

Ready to ship a production-ready marketplace for your boutique brand? Download the Marketplace Starter Kit for Boutique Manufacturers (includes boilerplate backend, React Native Expo app, CI config, and integration recipes). Get the kit, follow the 90-day playbook, and start accepting wholesale and subscription orders this quarter.

Get the Starter Kit → Visit reactnative.store/starter-kits or contact our team to tailor the pack to your manufacturing workflows.

reactnative

Contributor

Senior editor and content strategist. Writing about technology, design, and the future of digital media. Follow along for deep dives into the industry's moving parts.