How to Build a Course Marketplace App with Bubble

Udemy takes 50–75% of every sale on its platform. Building a course marketplace app with Bubble means the platform fee is yours to set, and the entire margin stays within your business.

Bubble handles multi-role users, Stripe Connect split payments, and relational data structures that multi-instructor marketplaces require. You configure the commission logic; Bubble and Stripe execute it automatically.

Key Takeaways

• Marketplace model: A course marketplace hosts courses from multiple instructors, handles split payments, and earns a platform commission on each sale.
• Data model: User, Course, Lesson, Enrollment, Review, Payout, and PlatformSettings data types drive the full marketplace lifecycle.
• Split payments: Stripe Connect handles instructor payouts and platform commission splits without manual reconciliation.
• Discovery: Search, category filters, ratings, and featured course logic require dedicated Bubble search and Algolia integration at scale.
• Build time: A solo MVP takes 80–100 hours; a full marketplace with discovery, reviews, and payouts runs 160–220 hours.

Bubble App Development

Bubble Experts You Need

Hire a Bubble team that’s done it all—CRMs, marketplaces, internal tools, and more

Let's talk

What Is a Course Marketplace App — and Why Build It with Bubble?

A course marketplace hosts content from multiple instructors, lets learners discover and purchase courses, splits payments between the platform and the instructor, and manages instructor accounts and payouts from a single admin interface.

This is distinct from a single-creator course platform. A marketplace earns a commission on every transaction and must manage dozens or hundreds of instructor relationships simultaneously.

• Multi-vendor complexity: Marketplaces require instructor onboarding, course approval workflows, revenue splits, and dispute resolution. None of this is handled by SaaS course tools built for custom commission models.
• Stripe Connect requirement: Split payments to instructors require Stripe Connect with standard or express connected accounts. Bubble's Stripe plugin supports this natively.
• Configurable commission logic: Store the platform commission percentage in a single PlatformSettings record. Every payout workflow reads from it. Change the commission once; it applies to all future transactions.
• Discovery infrastructure: Bubble's native search works for small catalogs. Algolia integration provides the fast, filterable search experience a marketplace needs at scale.

The range of apps you can build with Bubble shows why multi-vendor marketplaces are a common use case on the platform. The tooling for split payments and multi-role access is solid.

Custom marketplaces built on Bubble give you control over discovery algorithms, commission structures, and instructor relationships that no white-label marketplace platform will match.

What Features Should a Course Marketplace App Include?

An MVP course marketplace must let instructors publish courses, let learners discover and purchase them, and route the right money to the right parties. These eight features define that scope.

Course approval workflows are the feature most teams skip in the MVP and regret immediately after launch. Build it in from the start.

• Course catalog with search and filters: Learners browse by category, price range, rating, and keyword. Featured and trending courses surface via admin-curated or algorithmic flags on Course records.
• Instructor profiles: Each instructor has a public profile page with bio, profile image, and a list of their published courses and aggregate ratings.
• Enrollment with split payment: Learner pays via Stripe. The payment workflow uses a Stripe Destination Charge to route the instructor's net amount automatically, with the platform retaining the commission.
• Instructor dashboard: Instructors see enrollment counts, revenue by course, average rating, and per-course completion rates.
• Verified review system: Reviews are only submitted after a completed enrollment. Unverified reviews are rejected at the workflow level, not just hidden in the UI.
• Course approval queue: Instructors submit courses for review. Admin receives a notification, reviews the course, and either approves it (status to "published") or rejects it with a reason.
• Commission configuration: A PlatformSettings record stores commission_percent and min_payout_threshold. Admins update these values; payout workflows reference them dynamically.
• Refund and adjustment handling: Admin-triggered refunds reverse the Stripe transfer to the instructor and update the Payout record to deduct the refunded amount.

Before scoping, review Bubble's pros and cons so you understand where complex search and real-time updates have limitations at marketplace scale.

The refund and payout adjustment workflow is frequently the last thing built and the first thing that breaks in production. Test it against live Stripe test mode transactions before launch.

How Do You Structure the Database for a Course Marketplace in Bubble?

Seven data types power the marketplace. The PlatformSettings type is small but critical. It centralizes configurable business logic that every payout workflow depends on.

Build this schema before writing a single workflow. Marketplace data types are deeply interlinked; schema changes mid-build break multiple workflows simultaneously.

• User (extended): Add role (option set: learner/instructor/admin), stripe_account_id (text), and instructor_status (option set: pending/approved/suspended) to Bubble's default User type.
• Course: Fields are instructor (User), title (text), description (text), price (number), category (option set), status (option set: draft/pending-approval/published/suspended), avg_rating (number), total_students (number).
• Lesson: Fields are course (Course), title (text), content_type (option set: video/text/file), content_url (text), order (number), is_preview (yes/no).
• Enrollment: Fields are learner (User), course (Course), enrolled_date (date), status (option set: active/completed/refunded), stripe_payment_intent_id (text).
• Review: Fields are enrollment (Enrollment), rating (number 1–5), review_text (text), is_approved (yes/no), created_date (date). Linking to Enrollment rather than User ensures only paying learners can review.
• Payout: Fields are instructor (User), gross_amount (number), platform_fee (number), net_amount (number), period_end (date), status (option set: pending/paid), stripe_transfer_id (text).
• PlatformSettings: Fields are commission_percent (number), min_payout_threshold (number). This is a single record used by all payout calculation workflows.

Store stripe_payment_intent_id on each Enrollment. This is the reference needed to trigger refunds later. Without it, every refund requires manual lookup in Stripe's dashboard.

How Do You Build the Core Workflows for a Course Marketplace in Bubble?

Seven workflows cover the marketplace's critical paths. The split payment and payout workflows are the most complex and should be built and tested in Stripe test mode before going near production credentials.

Never expose Stripe payment or transfer logic in frontend workflows. Every Stripe action must run as a backend API workflow to prevent client-side manipulation.

• Workflow 1 - Instructor application: User submits instructor application. Update instructor_status to "pending." Admin receives a notification. On approval, status updates to "approved" and the user receives a Stripe Connect onboarding email via the Stripe API.
• Workflow 2 - Course submission: Instructor submits a course. Update Course status to "pending-approval." Admin receives a notification with a link to the review queue.
• Workflow 3 - Course approval: Admin reviews the course and clicks "Approve" or "Reject." On approval, Course status updates to "published" and instructor receives a confirmation email. On rejection, instructor receives a reason and the course reverts to "draft."
• Workflow 4 - Enrollment and split payment: Learner initiates checkout. Backend workflow creates a Stripe Destination Charge using the instructor's stripe_account_id. Stripe routes the net amount to the instructor and retains the platform commission defined in PlatformSettings. On payment success, create an Enrollment record with status = active.
• Workflow 5 - Monthly payout: Scheduled API Workflow fires on the first of each month. For each approved instructor, search Enrollments from the prior month, calculate gross revenue, deduct the platform fee, and create a Payout record. If net_amount exceeds min_payout_threshold, initiate a Stripe Transfer and store the stripe_transfer_id.
• Workflow 6 - Review moderation: After Enrollment status updates to "completed," display a review prompt. On submission, create a Review with is_approved = no. Admin receives a moderation notification. On admin approval, is_approved updates to "yes" and the review becomes publicly visible.
• Workflow 7 - Refund and adjustment: Admin triggers a refund using the Enrollment's stripe_payment_intent_id. Stripe reverses the destination charge (recovering the instructor's portion). Update Enrollment status to "refunded." Subtract the refunded amount from the instructor's pending Payout record.

Workflow 5 requires testing with multiple instructor accounts in Stripe test mode. Use Stripe's test clock feature to simulate month-end scenarios without waiting for calendar time.

What Security and Data Requirements Apply to a Course Marketplace?

A marketplace has three distinct user types: learners, instructors, and admins. Each requires different data visibility and modification rights. Privacy rules must enforce these boundaries at the database layer, not just the UI.

A privacy gap that exposes one instructor's earnings data to another is a critical failure in trust. Test cross-account visibility explicitly before launch.

• Lesson content gating: Lesson records are only visible to users with an active Enrollment for the parent Course. Lessons with is_preview = yes are publicly visible to support course discovery.
• Instructor data isolation: Instructors can only search and view Courses, Enrollments (aggregated counts only), and Payout records where they are the linked instructor.
• Admin full visibility: Admin role has a separate set of privacy rule exceptions that grant read/modify access across all data types. Admin pages redirect non-admin users on page load.
• Stripe account security: The stripe_account_id field must be marked as private in Bubble's privacy rules so it never appears in API responses or frontend data searches.
• Commission configuration: PlatformSettings records are editable only by admin role. A read-only privacy rule applies to all other roles.
• Review moderation: Reviews with is_approved = no are not visible in any public-facing search or display. Only the submitting learner and admin can see unapproved reviews.

Privacy rules in Bubble are applied per data type, not per field. Every new data type you add to the schema requires its own explicit privacy rule configuration.

What Plugins and Integrations Does a Course Marketplace Need?

Eight plugins and integrations cover the full production stack for a Bubble course marketplace. Algolia and Stripe Connect are the two that require the most setup time and should be configured early.

Algolia installation requires an API Connector configuration and a synchronization workflow that pushes Course records to the Algolia index on creation and update. Budget 8–12 hours for this setup.

• Stripe plugin with Connect: Handles split payments via Destination Charges, instructor account onboarding, monthly transfers, and refund reversals. Essential from day one.
• Vimeo or Wistia via API Connector: Hosts private lesson videos. Privacy settings prevent direct URL sharing. Wistia provides per-viewer analytics; Vimeo is more cost-effective.
• SendGrid plugin: Sends instructor approval and rejection notifications, enrollment confirmations, payout reports, review moderation alerts, and re-engagement emails.
• Algolia via API Connector: Provides fast, typo-tolerant, faceted search across the course catalog. Bubble's native search does not scale to marketplace-level catalog queries efficiently.
• PDF Conjurer plugin: Generates completion certificates for learners and monthly earnings statements for instructors.
• Bubble Scheduler (built-in): Runs monthly payout calculations and weekly inactive learner re-engagement campaigns without needing an external job scheduler.
• Segment via API Connector: Tracks marketplace funnel events. Course viewed, enrollment started, payment completed, and completion milestones feed platform health analytics.
• Crisp or Intercom plugin: Provides in-app support chat for learner questions and instructor communications without requiring email.

Algolia adds meaningful cost ($35/month for the Lite plan) but solves a real problem at scale. Deploy it when your catalog exceeds 200 courses or when search performance becomes a visible issue.

How Long Does It Take and What Does It Cost to Build a Course Marketplace with Bubble?

A course marketplace is the most complex of the education platform types. The split payment system, course approval workflow, and review moderation layer are all unique to the marketplace model and each adds meaningful build time.

Validate the Stripe Connect integration end to end in test mode before building the discovery and review features. Payment failures in production are far more expensive than late UI work.

• Bubble plan: Team ($529/month) for multi-instructor production. Growth ($29/month) for a solo MVP in development.
• Stripe Connect costs: 0.25% per transfer plus $2 per payout. Budget this into your commission model so payouts remain profitable.
• Algolia costs: Lite plan at $35/month covers up to 10,000 records and 50,000 search operations.
• Vimeo costs: Pro at $20/month for standard video hosting. Premium at $75/month for private video and analytics.

Map your expected transaction volume against Bubble's pricing plans before deciding between Growth and Team tier for your launch configuration.

The two most expensive mistakes on marketplace builds are designing split payments as an afterthought and skipping the course approval workflow. Both require significant rework if added late.

Conclusion

Bubble can power a full multi-instructor course marketplace with split payments, discovery, and commission logic at a fraction of custom development cost. The Stripe Connect integration and relational data model are the technical foundation.

Start with the Stripe Connect onboarding workflow and course approval flow. These are the hardest parts and should be validated before building the learner-facing catalog or review system.

Bubble App Development

Bubble Experts You Need

Hire a Bubble team that’s done it all—CRMs, marketplaces, internal tools, and more

Let's talk

Need Help Building Your Course Marketplace in Bubble?

Course marketplace architecture involves Stripe Connect split payments, multi-role access control, and instructor approval workflows that must be sequenced correctly from day one. Getting any of these wrong requires a full rebuild.

• Data architecture: We design your data types, option sets, and privacy rules before writing a single element on the canvas.
• Workflow engineering: We build backend workflows, scheduled jobs, and API integrations with proper logic and error handling.
• Plugin configuration: We select and configure the right Bubble plugins for your feature set without unnecessary bloat.
• Role-based access: We implement privacy rules at the database level, not just conditional UI visibility.
• Integration setup: We connect your Bubble app to Stripe, SendGrid, Twilio, and other services correctly from day one.
• Pre-launch testing: We test against real data before deployment so every workflow performs correctly under live conditions.
• Post-launch support: We stay involved after go-live to optimize as real usage data shapes the app.

We have built 350+ products for clients including Coca-Cola, American Express, Sotheby's, and Medtronic. We know exactly where Bubble builds fail and we address those problems before they surface.

If you want your Bubble app built correctly from day one, let's scope it together.