How to Build a Marketplace App in 2026: Architecture, Payments, and the Hard Parts

A marketplace looks simple: sellers list things, buyers buy them, platform takes a percentage. Airbnb, Etsy, Fiverr, OLX, Avito - all the same model at different scales.

The complexity is in the details: who owns the money between purchase and delivery, how you handle disputes, how you prevent fraud on both sides, how you build search that shows the right listings to the right buyers. These are the problems that take time. This guide covers them honestly.

---

Types of marketplaces

Before architecture decisions, know which type you're building:

Product marketplace (Etsy, eBay, OLX) - sellers list physical goods, buyers purchase, goods ship

Service marketplace (Fiverr, Upwork, TaskRabbit) - sellers offer services, buyers hire them, delivery is the work itself

Rental marketplace (Airbnb, Turo) - temporary access to assets, platform manages availability and booking

Lead marketplace (Thumbtack, HomeAdvisor) - buyers post requests, sellers bid, platform earns from seller subscriptions or bid fees

The architecture differs significantly. Product marketplaces need inventory management and shipping integration. Service marketplaces need work delivery verification and milestone payments. Rental marketplaces need calendar management and availability conflicts. Lead marketplaces need matching algorithms.

This guide focuses primarily on product and service marketplaces.

---

Core data model

User
├── role: buyer | seller | both
├── profile (varies by role)
└── verification_level: unverified | email | id | business

Listing
├── seller_id → User
├── title, description, price, category
├── images[]
├── stock (for products) | availability (for services)
└── status: draft | active | paused | sold | removed

Order
├── buyer_id → User
├── seller_id → User
├── listing_id → Listing
├── quantity, total_price, platform_fee, seller_payout
├── status: pending_payment | paid | processing | shipped | delivered | disputed | refunded
└── fulfillment details

Payment
├── order_id → Order
├── amount, currency, platform_fee_amount
├── payment_intent_id (Stripe)
├── status: pending | captured | transferred | refunded
└── payout_scheduled_at

Review
├── order_id → Order (can only review after completed order)
├── reviewer_id → User, reviewee_id → User
├── rating (1-5), body, response
└── verified: true (platform confirms transaction happened)

The critical design decision: payment goes through the platform, not directly to the seller. This is what enables everything: dispute resolution, buyer protection, platform fees, fraud prevention. If buyers pay sellers directly, you can't intervene in disputes and you can't take a fee.

---

Payment architecture: the hard part

Multi-party payment flow

A marketplace payment has three parties:

1. Buyer pays platform
2. Platform holds funds
3. Platform pays seller (minus fee)

Stripe Connect is the standard solution in 2026 for international marketplaces. It handles the regulatory complexity of paying sellers in different countries, the escrow-like holding period, and the transfer to seller accounts.

// 1. Seller onboards: creates a Stripe Connected Account
const account = await stripe.accounts.create({
  type: 'express', // 'standard' gives seller a full Stripe dashboard; 'express' is streamlined
  country: 'US',
  capabilities: {
    card_payments: { requested: true },
    transfers: { requested: true },
  },
});
// Save account.id to seller's profile

// 2. Buyer pays: create PaymentIntent with application_fee
const paymentIntent = await stripe.paymentIntents.create({
  amount: 5000, // $50.00 in cents
  currency: 'usd',
  application_fee_amount: 500, // $5.00 = 10% platform fee
  transfer_data: {
    destination: sellerStripeAccountId,
  },
  metadata: {
    order_id: orderId,
    buyer_id: buyerId,
    seller_id: sellerId,
  },
});

// 3. Hold funds: don't transfer to seller immediately
// Set transfer_data.destination but use capture_method: 'automatic'
// with on_behalf_of or handle via payouts schedule

// 4. Release to seller: after delivery confirmed (or hold period)
const transfer = await stripe.transfers.create({
  amount: 4500, // $45.00 (total minus fee)
  currency: 'usd',
  destination: sellerStripeAccountId,
  transfer_group: orderId,
});

For CIS markets, Stripe has limited availability. Alternatives:

• Kaspi Pay (Kazakhstan) - dominant for KZ, no international sellers
• YooKassa - Russia market, supports marketplace splits
• CloudPayments - Russia, supports multi-party flows
• Custom escrow - hold funds in a platform wallet, payout via bank transfer. More complex, more regulatory requirements.

Holding period

Don't transfer to sellers immediately. Hold funds for a period that allows:

• Buyer to receive and verify the goods (3-7 days for physical goods)
• Dispute window to pass (14-30 days for high-value items)
• Fraud detection to run

The holding period is also your leverage in disputes. Once money is gone to the seller, getting it back requires their cooperation or legal action.

// Schedule payout after hold period
async function scheduleSellerPayout(orderId) {
  const order = await Order.findById(orderId);
  const holdDays = calculateHoldDays(order); // based on category, seller rating, etc.
  
  const payoutDate = new Date();
  payoutDate.setDate(payoutDate.getDate() + holdDays);
  
  await Order.update(orderId, {
    payout_scheduled_at: payoutDate,
    status: 'payout_pending',
  });
  
  // Queue a job to run at payoutDate
  await payoutQueue.add(
    { orderId },
    { delay: payoutDate - Date.now() }
  );
}

---

Search and discovery

Search is the core product for most marketplaces. A buyer who can't find what they want leaves. A seller whose listing doesn't appear in relevant searches can't sell.

Full-text search

Elasticsearch or Meilisearch for listing search. PostgreSQL full-text search works for small catalogues but lacks the ranking, fuzzy matching, and faceted filtering you need at scale.

// Index a listing in Meilisearch
await meiliIndex.addDocuments([{
  id: listing.id,
  title: listing.title,
  description: listing.description,
  category: listing.category,
  tags: listing.tags,
  price: listing.price,
  seller_rating: listing.seller.rating,
  created_at: listing.createdAt,
}]);

// Search with filters and ranking
const results = await meiliIndex.search('vintage camera', {
  filter: ['price < 500', 'category = electronics'],
  sort: ['seller_rating:desc', 'price:asc'],
  facets: ['category', 'price_range', 'location'],
  hitsPerPage: 24,
  page: 1,
});

Ranking factors

Pure text relevance is insufficient. Real marketplace search ranking includes:

• Transaction velocity: listings that sell frequently rank higher
• Seller quality: higher-rated sellers get a boost
• Listing quality: more photos, longer description, faster response time
• Price competitiveness: within category benchmarks
• Recency: fresh listings, recently active sellers
• Personalization: user's browse and purchase history

Build this into your ranking model from the start. Changing ranking fundamentally after sellers have optimized for old ranking criteria causes seller backlash.

---

Trust and safety

Marketplaces fail when either side can't trust the other. Buyers fear receiving a broken item or nothing at all. Sellers fear fraudulent chargebacks after delivering legitimate goods.

Seller verification

Minimum tiers for product marketplaces:

Tier 0 (unverified): email confirmed, limited to low-value listings (< $50), limited volume Tier 1: phone verified, ID uploaded (Stripe Identity or similar), can list up to $500 Tier 2: ID verified by platform, can list any price, lower fee, higher payout speed Business tier: company registration verified, unlimited, dedicated support

// Seller limitations by verification level
const SELLER_LIMITS = {
  unverified: { max_listing_price: 50, max_active_listings: 5, payout_hold_days: 14 },
  phone_verified: { max_listing_price: 500, max_active_listings: 25, payout_hold_days: 7 },
  id_verified: { max_listing_price: null, max_active_listings: null, payout_hold_days: 3 },
  business: { max_listing_price: null, max_active_listings: null, payout_hold_days: 1 },
};

Dispute resolution

Every marketplace needs a dispute system. You'll deal with:

• "Item not received" (shipping lost, seller never shipped)
• "Not as described" (photos misleading, condition misrepresented)
• "Counterfeit item" (fake branded goods)
• "Unauthorized transaction" (buyer's account compromised)

The minimum viable dispute flow:

1. Buyer opens dispute (within X days of delivery)
2. Seller has Y days to respond and provide evidence
3. Platform reviews evidence and decides
4. Funds held during dispute
5. If platform rules for buyer: refund from held funds
6. If platform rules for seller: release held funds to seller

You need a human review process, even as a small team. Automated dispute resolution leads to bad outcomes and platform trust erosion.

---

Reviews and reputation

A review system that can be gamed is worse than no reviews. Common manipulation patterns:

• Seller self-reviews: fake buyer accounts leaving 5-star reviews
• Competitor bombing: fake 1-star reviews on competitors
• Review extortion: seller threatens negative review if buyer requests refund
• Incentivized reviews: seller offers discount for 5-star review

Protections:

// Review gating: only completed, verified purchases can leave reviews
async function canLeaveReview(reviewerId, listingId) {
  const completedOrder = await Order.findOne({
    buyer_id: reviewerId,
    listing_id: listingId,
    status: 'delivered',
    disputed: false,
    // Review window: 30 days after delivery
    delivered_at: { $gte: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) },
  });
  
  const alreadyReviewed = await Review.findOne({
    reviewer_id: reviewerId,
    listing_id: listingId,
  });
  
  return !!completedOrder && !alreadyReviewed;
}

Display verified reviews prominently. Mark reviews from verified purchases differently from unverified. This alone reduces fake review impact significantly.

---

Commission structure

Marketplace fee models:

Model	How it works	Best for
Percentage of sale	Platform takes 5-20% of transaction	Most product/service marketplaces
Listing fee	Charge per listing posted	High-volume sellers (Etsy model)
Subscription	Sellers pay monthly for access	B2B marketplaces, tool rentals
Freemium	Free basic, paid features (featured listing, analytics)	Classifieds, lead gen
Buyer fee	Add fee to buyer's price	Travel, ticketing

For most starting marketplaces: pure percentage fee. Simple to explain, aligns incentives (platform earns when seller earns), no upfront cost barrier for sellers.

---

What to build for MVP vs later

MVP (launch-ready)

• Seller listing creation (photos, description, price, category)
• Buyer search and browse
• Checkout with single payment method
• Order management (buyer and seller view)
• Basic messaging between buyer and seller
• Email notifications at key order states
• Admin panel to review listings and manage disputes

Skip for MVP

• Mobile apps (web-responsive first)
• AI-powered recommendations
• Advanced analytics for sellers
• Subscription tiers
• Localization for multiple markets
• API for third-party integrations

The marketplace is viable when it has its first 10 successful transactions between real strangers who didn't know each other before using the platform. Everything before that is overhead.

---

The chicken-and-egg problem

Marketplaces face the hardest cold start in product: buyers won't come without sellers, sellers won't come without buyers.

Solutions that work:

Seed the supply side manually. Don't build a self-serve seller onboarding until you have 50 sellers onboarded manually. Onboard sellers yourself: call them, meet them, do the work by hand. Once you have supply, you have something to show buyers.

Constrain the geography. Don't launch globally. Launch in one city. OLX launched city by city. Airbnb focused on NYC first. Supply and demand in one city are much easier to balance than supply and demand nationally.

Launch around an event. Airbnb's first real traction came from renting space during a conference where hotels were sold out. Identify concentrated demand events and seed supply specifically for them.

Be the seller first. Some marketplaces sourced initial inventory themselves before opening to third-party sellers. Cheating, but it works for demonstrating the buyer experience.

The technology is the easy part. The marketplace flywheel is the hard part. Build only what you need to run the flywheel. Don't build the full platform for a marketplace that doesn't have product-market fit yet.

---

Aunimeda builds software products for businesses - websites, mobile apps, automation systems, and custom platforms.

Contact us to discuss your project. See also: Web Development, Mobile App Development