Asia/Karachi
BlogNovember 14, 2026

How to Build a Fashion Marketplace Like Myntra

What changes when the products come in sizes, colours and seasons
Fawaz Israr
How to Build a Fashion Marketplace Like Myntra
To build a fashion marketplace like Myntra, you take a normal multi-vendor platform and change four things: the product model (one style, many size and colour variants), the catalogue intake (sellers upload hundreds of items in bulk), search (filters matter more than keywords) and returns (they are routine, so they need their own workflow). Everything else, such as roles, sub-orders and commission, is the standard multi-vendor design. Myntra appears here only as a familiar example of a multi-brand fashion marketplace. I have no connection to the company, and I am describing the general model, not how any company builds its own system. I am a final-year Computer Science student, so treat this as design guidance for scoping a project. I have not run a fashion marketplace. A fashion marketplace is a site where many brands and sellers list clothing, shoes and accessories, while the platform owns discovery (browse, search, filters) and checkout. Customers deal with one cart, one payment and one account. Sellers deal with stock, packing and shipping. The platform earns a commission on each sale, and that commission is usually a percentage that can differ by category. If you want the generic version of that structure (customers, vendors and admins, vendor-owned products, commission ledgers), I covered it in how to build a multi-vendor e-commerce platform. I will not repeat it here. This post is about what fashion adds on top. Three things set fashion apart from, say, a store selling phone accessories. First, one product is really many sellable items: the same shirt exists in five sizes and three colours. Second, buyers cannot try things on, so size guidance and returns carry a lot of weight. Third, catalogues are large and seasonal, so sellers cannot create products by hand one at a time.
A woman in sunglasses and a burgundy coat carrying several paper shopping bags
Separate the style from the variant. A style is what the customer browses: a title, brand, description, fabric, fit and images. A variant is what the customer buys: a specific size in a specific colour, with its own SKU and its own stock. If you put size and colour on the product row, you end up either duplicating the description for every size or storing sizes in a comma-separated string, and both break the first time you need stock per size. Stock needs a second thought in a marketplace. Quantity belongs to a variant and to a seller, because two sellers can in principle list the same branded item. Here is a sketch in Prisma that I checked against the schema syntax in the Prisma docs:
Prisma
model Seller {
  id         String        @id @default(cuid())
  name       String
  commission Int           @default(1000) // basis points: 1000 = 10%
  stock      SellerStock[]
}

model Brand {
  id     String  @id @default(cuid())
  name   String  @unique
  styles Style[]
}

model Style {
  id       String    @id @default(cuid())
  brandId  String
  brand    Brand     @relation(fields: [brandId], references: [id])
  title    String
  gender   String
  category String
  fabric   String?
  fit      String?
  season   String?   // for example "SS27"
  variants Variant[]

  @@index([brandId])
  @@index([category, gender])
}

model Variant {
  id      String        @id @default(cuid())
  styleId String
  style   Style         @relation(fields: [styleId], references: [id])
  sku     String        @unique
  colour  String
  size    String
  stock   SellerStock[]

  @@unique([styleId, colour, size])
}

model SellerStock {
  id         String  @id @default(cuid())
  variantId  String
  variant    Variant @relation(fields: [variantId], references: [id])
  sellerId   String
  seller     Seller  @relation(fields: [sellerId], references: [id])
  quantity   Int
  priceMinor Int     // price in the smallest currency unit

  @@unique([variantId, sellerId])
  @@index([sellerId])
}
In this sketch the style is shared catalogue data and each seller lists stock against its variants. If every style belongs to exactly one seller, which is common when brands upload their own catalogue, put a sellerId on Style and keep quantity directly on Variant. That is simpler, and you can add the shared-catalogue model later if you ever need it. For indexes, delete rules and money handling in more depth, see Prisma schema design for e-commerce. Several fashion details sit around this core. Size charts are data, not images: store the measurements per size for each brand or category, so the product page can show them and a "which size am I" helper can use them later. Images belong to a style and a colour, since the red shirt needs red photos, and each needs several angles plus a zoomed view. Seasonal collections are a tag on the style (the season field above) plus a collection page, so you can retire a season without deleting history. Attributes need discipline. Colour, fit, sleeve length, pattern and occasion should come from controlled lists, not free text, otherwise the filter sidebar shows "Navy", "navy blue" and "Dark Blue" as three options. Nobody lists a season of clothing through a one-item-at-a-time form. Plan for bulk upload from the start, usually a CSV or spreadsheet with one row per variant: style code, title, brand, category, colour, size, SKU, quantity, price and image file names. The importer groups rows by style code, creates the style once and attaches the variants. Validate the file before importing anything and show the seller a row-by-row error report. Reject unknown categories and colours, duplicate SKUs and missing sizes. A half-imported catalogue is worse than a rejected file. Set image rules in writing: minimum dimensions, a plain background, a fixed number of angles and no watermarks on the photo. Enforce what you can in code (file type, dimensions, size) and leave the rest to moderation. Moderation means a new seller, and ideally each new listing from a new seller, waits for admin approval before going live. A simple status on the style (draft, pending, live, rejected, with a reason) is enough. It also gives you the place to catch counterfeit goods and misleading titles. I would build this approval queue before building anything fancy for customers. Not on day one. PostgreSQL has built-in full-text search: it turns text into a tsvector, matches it against a tsquery, ranks results and handles stemming, so "dresses" can match "dress". The PostgreSQL full-text search documentation explains it well, and it was on version 18 when I checked in November 2026. For a catalogue of a few thousand styles, Postgres search plus ordinary indexed filters on brand, category, size, colour and price is a reasonable first version, and it avoids running a second system. A dedicated engine such as Elasticsearch, OpenSearch, Meilisearch or Typesense starts to pay off when the catalogue grows large, when filter counts ("Blue (214)") must update instantly as shoppers combine filters, when you want tolerance for typos, or when you want custom ranking such as boosting in-stock items and new arrivals. Postgres can be stretched toward some of this (the pg_trgm extension helps with misspellings, and grouped queries can produce facet counts), but the effort grows with the catalogue. If you do add one, keep Postgres as the source of truth and treat the search index as a copy that a background job updates when a style or its stock changes. Fashion filters care about availability per size, so index each style with the list of sizes currently in stock. Otherwise a shopper filters by size M and lands on pages where M is sold out. Checkout follows the usual marketplace pattern: one parent order for the customer, and one sub-order per seller, each with its own shipping status. Stock is decremented inside the transaction that creates the order, with a conditional update so two buyers cannot take the last size M. The generic version is in my multi-vendor architecture post, so I will concentrate on what is different here. Returns are the part of fashion that surprises first-time builders. Because people order a size, try it, and send it back when it does not fit, returns and exchanges are an everyday event and not an edge case. Design for them early:
  • Track returns per item, not per order. A customer returns one of three items from one seller.
  • Give the return a return window (a number of days after delivery, set per category or per seller), and compute eligibility from the delivery date.
  • Give each return request its own status: requested, approved, picked up, received, inspected, refunded or rejected.
  • Support exchanges as a first-class option. An exchange is a return plus a new sub-order for another size, and it keeps the sale alive.
  • Route the refund to the right place. The refund comes out of that seller's sub-order, the commission on it is reversed, and the ledger records both.
Write the policy down before you code it. Who pays return shipping, which categories are final sale (innerwear is a common one), and who decides when a seller and a customer disagree are business rules that the software only enforces. The customer pays the platform once, and the platform later owes each seller their subtotal minus commission, usually after the return window closes. That delay is why a ledger of sales, refunds and payouts, as opposed to a balance field, matters here: refunds arrive weeks after the sale. Stripe Connect is the product Stripe describes for marketplaces that collect payments and pay out a portion to sellers. Check availability before you design around it. When I looked at Stripe's list of supported countries in November 2026, Pakistan was not on it, and its cross-border payout documentation only covered platforms in a short list of regions (the US, UK, EEA, Canada and Switzerland). Rules like this change, so read Stripe's pages yourself, and ask them, before you build on it. If your platform or sellers are in a country Stripe does not support, you will likely use a local payment gateway or cash on delivery for collection, and handle payouts to sellers as ledger entries that an admin settles by bank transfer. That is manual, but it is honest and it works for a first version. Start recommendations with plain rules: recently viewed items, more from the same brand, and more from the same category. These are simple queries, they need no machine learning, and they are good enough until you have real behaviour data to learn from. Fashion is image-heavy, so images decide your page speed. Serve responsive sizes and modern formats, put them behind a CDN, and load the below-the-fold ones lazily. If you build on Next.js, the next/image component handles resizing, format selection and lazy loading, and its sizes prop tells the browser which width to fetch. Reserve space for every image so the layout does not jump while a grid of photos loads, and read my post on Core Web Vitals for why that matters. Design for the phone first, since a large share of online shoppers browse on mobile. Filters should open as a bottom sheet, the size picker should be one tap, and the cart should be reachable from any page. Trust is a feature. Verified-purchase reviews, a visible return policy, clear seller names on each product and a way to report a listing all help a shopper buy from a brand they have never heard of. Authenticity is a policy as much as a technology problem: seller verification and moderation catch most of it. A marketplace tries to build everything at once and ships nothing. Order the work by risk, and write down what you will postpone. This is the scope I would propose for a first release:
Text
Phase 1: prove sellers will list and customers will buy
  - Accounts, roles, seller onboarding with admin approval
  - Style and variant model, size per variant, stock per variant
  - Bulk CSV upload with a validation report
  - Category pages, basic filters (brand, size, colour, price)
  - Cart, checkout, parent order and per-seller sub-orders
  - Return request per item, manual refund by admin
  - Ledger for sales, refunds and commission

Phase 2: make it pleasant to use
  - Postgres full-text search with in-stock size filter
  - Exchanges, return pickup tracking, seller dashboards
  - Reviews from verified buyers
  - Rules-based recommendations
  - Image zoom, size charts, wishlist

Phase 3: grow it
  - Dedicated search engine if filters or catalogue size need it
  - Automated payouts through a payment provider
  - Seasonal collections and campaigns
  - Size recommendation, personalised feeds, coupons
My own experience here is the generic part. GoCart, my final-year project, is a multi-vendor e-commerce platform with vendor dashboards, product catalogue management, order workflows and role-based access control. Its AI features are still in development. It is not a fashion product, so everything fashion-specific above is design guidance and not something I have shipped. For picking the stack for a first release, my MVP tech stack guide applies unchanged, and you can read more about me. I am Fawaz Israr, a full stack developer in Rahim Yar Khan, Pakistan, a final-year Computer Science student, and I work in web development at Hadi Dev Lab. If you are scoping a fashion or multi-brand marketplace and want a second opinion on what belongs in the first release, you can message me on WhatsApp or email. You can also browse my work first. Cover photo from Unsplash.
Share this post: