Is Base44 right for marketplaces?
With caveats. Marketplaces are where Base44's real-time ceiling shows first. Its documented realtime is record-change subscriptions through entities.subscribe() (docs.base44.com): new bids, new messages, order-status changes and inventory counts can reach the screen as they are written. Custom socket channels for presence, typing indicators or multiplayer state are not documented. Service marketplaces and slow-moving B2B niches rarely need more than record updates. A live-auction or live-commerce product that depends on who is watching and who is typing needs a third-party socket service bolted on.
The honest read: Base44 is a fast way to validate whether your marketplace thesis works at all. If users won't list and won't book on an MVP without presence indicators, they won't book on a Pusher-backed v2 either. Use Base44 to disprove the demand-side hypothesis cheap. If you survive that test, plan the migration to a stack with real-time as a first-class primitive.
What you can build
Marketplaces that fit Base44's shape:
- Service marketplaces — hire a tutor, book a coach, find a consultant. Listings are static, booking is asynchronous, payment happens once per transaction. Polling-friendly.
- Curated directories — paid listings in a vertical niche (e.g., "best agencies for SaaS marketing"). Subscription-based seller side, free buyer side, lead-form handoff. Almost no real-time needs.
- B2B procurement — RFQ, quote, contract. Long-cycle, document-heavy, polling is fine.
- Lead-generation marketplaces — buyers fill a form, sellers buy access to the lead. Stripe one-time payment per lead purchased, no escrow.
What does not fit:
- Live-auction marketplaces (eBay-style, sneaker drops, NFT mints) — sub-second bid ordering and who-is-watching presence are the product, and Base44 documents record subscriptions only.
- High-frequency booking (ride-hailing, food delivery) — real-time matching is the product.
- Chat-native marketplaces (Whatnot-style live commerce) — live video and presence channels are the moat.
- Anything with regulated escrow (legal, real estate trust accounts) — compliance posture is wrong.
Critical patterns for marketplaces
1. Two-sided identity: users + seller_profiles
Base44's user model is single-role. Marketplaces need users to be buyers, sellers, or both. The pattern:
// Collections
users {
id, email, name, default_role: 'buyer' | 'seller'
}
seller_profiles {
id, user_id (FK), stripe_connect_account_id,
kyc_status: 'pending' | 'verified' | 'rejected',
payout_schedule: 'instant' | 'weekly' | 'monthly',
trust_tier: 'new' | 'verified' | 'top',
total_listings: number, total_sales: number, rating: number
}
listings {
id, seller_profile_id (FK), title, price_cents,
status: 'draft' | 'active' | 'sold' | 'archived',
// ... domain fields
}
orders {
id, listing_id, buyer_user_id, seller_profile_id,
amount_cents, fee_cents, escrow_status: 'held' | 'released' | 'refunded',
stripe_payment_intent_id
}
The discipline: every read of a listing or order joins through seller_profiles so RLS rules can enforce "you can only act on your own seller account." This pattern survives migration cleanly.
2. Escrow: Stripe Connect with manual capture
The flow that works:
Buyer creates order -> Base44 backend function creates PaymentIntent
with capture_method='manual', destination=seller_account
-> Stripe authorizes the buyer's card (funds held)
-> Order status: 'authorized'
Seller delivers -> Order moves to 'delivered'
Buyer confirms (or 7d) -> Backend function calls stripe.paymentIntents.capture()
(transfers minus platform fee to seller)
-> Order status: 'released'
Buyer disputes -> Backend function calls stripe.refunds.create()
-> Order status: 'refunded'
The capture window is the trap. Stripe holds authorizations for 7 days for cards. Disputes that drag past 7 days force you to capture-and-refund instead of release-or-cancel, which leaves a paper trail that complicates accounting. Build dispute handling into the order state machine from day one.
3. Search: filter UI now, Algolia later
Up to 5,000 listings, Base44's collection filters cover most search needs; 5,000 is also the most one list() or filter() request returns (docs.base44.com, read 25 Sep 2026). UI: category dropdown, price range, location filter, sort by created_at or price. Past 5,000, you sync to Algolia:
// On every listing write, in backend function:
async function syncListingToAlgolia(listing) {
await algolia.saveObject({
objectID: listing.id,
title: listing.title,
description: listing.description,
category: listing.category,
price: listing.price_cents / 100,
location: { lat: listing.lat, lng: listing.lng },
seller_trust_tier: listing.seller.trust_tier,
_tags: listing.tags,
});
}
Frontend queries Algolia directly with a search-only API key. Backend handles writes. Clean separation, $30–100/month at modest scale.
4. Real-time: record subscriptions first, Pusher when forced
Anything that is a record — a bid, a chat message, an order moving to delivered — can stream through the SDK. entities.subscribe() delivers every create, update and delete on an entity, so filter to the auction on screen:
// Frontend: live bid list for one auction
const unsubscribe = base44.entities.Bid.subscribe((event) => {
if (event.type === 'create' && event.data.auction_id === auctionId) {
setBids((prev) => [event.data, ...prev]);
}
});
// Call unsubscribe() when the auction page unmounts
Presence, "X is typing" and live video are not record changes, and Base44's docs describe no channel for them. Either store last_seen_at on the user's row and poll it every 5–10 seconds, or wire Pusher Channels through a backend function:
// Backend function: typing.ts — ephemeral state, never stored
await pusher.trigger(`order-${orderId}`, 'typing', {
user_id, ts: Date.now()
});
Base44 owns every record; Pusher carries only the state you would never store. If Pusher is down, the marketplace loses its typing dots, not its bids.
5. Trust and safety: review queue + manual escalation
Marketplaces need moderation. There is no native moderation UI on Base44, so you build it:
- Every new listing, review, and chat message lands in a
moderation_queuecollection with statuspending. - A small admin UI (built on Base44, gated by an
is_adminflag on users) shows pending items with approve/reject buttons. - AI-assisted triage is straightforward: a backend function calls a moderation API (OpenAI moderation, Perspective) on write and auto-approves anything below a threshold.
Plan for 4–6 hours per week of human moderation work for any marketplace past 100 listings. The platform will not do this for you.
Limitations and gotchas
| Limitation | Impact | Workaround |
|---|---|---|
| Realtime limited to record-change subscriptions | Bids and messages can stream; presence and typing cannot | entities.subscribe() for records; Pusher/Ably ($50–200/mo) for presence |
| Single-role user model | Buyer-seller duality awkward | Side-table seller_profiles |
| No full-text search | Search degrades past 5k listings | Algolia or Meilisearch |
| Webhooks need active users | Stripe Connect events lost overnight | External webhook proxy |
| No native moderation | T&S is 100% custom | moderation_queue + admin UI |
| 5,000-item request limit | Bulk seller imports break | Pagination + queue |
| RLS defaults open | Cross-seller data leak | Manual seller_profile_id filter on every rule |
| No background jobs UI | Payout schedule debugging is painful | External cron + retry log collection |
| Mobile app review | Base44's store build (Builder plan and up) is a web-view wrapper, which Apple's guideline 4.2 turns away when the app is not "particularly useful, unique, or 'app-like'"; in-app purchases are "Not yet" supported, so paid listings and paid lead access cannot be sold inside the app | Stripe stays fine for bookings and physical goods; sell digital extras on the web (App Store rejection guide) |
| No reputation system | Reviews are entirely yours to design | Build it; align with vertical norms |
The expensive mistake for a marketplace team: realizing after launch that webhook reliability matters and rebuilding the Stripe Connect event handling on a Cloudflare Worker.
Real-world example architecture
An example service-marketplace MVP on Base44:
Collections:
- users (id, email, default_role)
- seller_profiles (user_id, stripe_connect_id, kyc_status, trust_tier)
- listings (seller_profile_id, title, price, category, location)
- orders (listing_id, buyer_user_id, escrow_status, stripe_pi_id)
- messages (order_id, sender_user_id, body, read_at)
- reviews (order_id, rating, body, public)
- moderation_queue (entity_type, entity_id, status, reason)
- audit_events (actor, event, entity, ts)
External services:
- Stripe Connect -> escrow + payouts
- Cloudflare Worker -> Stripe webhook reliability
- Algolia (optional, post-5k) -> search
- Pusher (optional) -> real-time chat presence
- Postmark -> transactional email
- Twilio -> SMS for booking confirmations
Key flows:
- Seller onboarding -> Stripe Connect Express -> KYC redirect -> seller_profile complete
- Listing creation -> moderation queue -> AI auto-approve OR human review
- Order placement -> Stripe authorize -> escrow held -> seller delivers -> capture
- Dispute -> refund flow -> dispute_events log -> manual review
- Payout -> Stripe Connect payout schedule -> webhook -> seller_profile total update
On our build tiers this stack is Standard ($9,000, 4–6 weeks) or Premium ($15,000, 6–10 weeks) work, depending on how much escrow and search integration it needs. Once listings approach the 5,000 search threshold above, the migration conversation starts.
Cost to ship
For a marketplace at 500 active listings, 200 monthly transactions, $50 average order:
| Line item | Monthly | One-time |
|---|---|---|
| Base44 Pro or Elite plan (no credit top-up is documented; you move up a tier) | $80–200 | — |
| Cloudflare Worker (webhooks) | $5 | $300 |
| Stripe Connect fees (~$10k GMV) | $290 + $0.25/payout | — |
| Postmark | $50 | — |
| Algolia (deferred until 5k listings) | $0–50 | $1,500 setup if needed |
| Sentry | $26 | — |
| Manual moderation labor | $400–800 | — |
| Build (escrow, onboarding, search, T&S) | — | $9,000–15,000 |
| Total | ~$850–1,420/mo + per-payout fees | ~$9,000–15,000 |
Comparable Next.js + Supabase + Stripe + Algolia stack: $150–250/month operational, $30,000–50,000 initial build. Base44 is meaningfully cheaper to start, less expensive at scale only if you stay under the ceilings.
Migration off-ramp
The clean migration target is Next.js + Supabase + Algolia + Stripe Connect. Component model maps. Postgres gives you full-text search out of the box (you can defer Algolia). Supabase Realtime adds the Presence and Broadcast channels Base44 does not document, so who-is-online and typing indicators stop needing a third-party service. Stripe Connect carries over unchanged. We document the playbook in the Next.js + Supabase migration guide. Hired out, it is fixed-price on our published migration tiers: $12,000 for up to 20 tables with multi-role auth and Stripe (4–5 weeks), and $25,000+ for multi-tenant or SOC 2 / HIPAA-compatible work, quoted in a written proposal within one week. How deep the SDK calls leaked into the React components decides how much of the frontend gets rewritten.
Get this scoped
If you are building a marketplace on Base44 and want to know whether the architecture will hold up to your traffic projections, our standard build engagement covers the escrow, onboarding, and moderation plumbing end-to-end. Or if you have a marketplace already live and want a written assessment of where the scale ceilings will hit, the $497 production audit maps the failure modes against your actual data volumes.
Book a 15-minute call to scope your marketplace
Related
- Solutions hub — every Base44 vertical fit verdict in one matrix.
- Base44 for SaaS: multi-tenancy patterns
- Base44 for ecommerce: Stripe and inventory
- $497 production audit — written verdict on escrow, search, and scale ceilings for your marketplace.
- Stripe integration breaks after updates
- Webhooks require active users: the dunning gap
- Bulk deletes at scale with deleteMany
- Migrate Base44 to Next.js + Supabase
- Written by the Lead Engineer at Base44Devs from marketplace audits and rebuilds.