Cohort-Based Course Platform: Build, Buy or Combine Tools

A cohort-based course platform runs a course as a group that starts on a fixed date: scheduled live sessions, weekly modules that unlock together, a community, assignments with deadlines and a certificate at the end. Most creators should combine or rent tools first; Maven lets experts keep 90% of sales (Maven). Build when cohorts are your product, sold to companies or paid through local rails.

If you would rather have it built for you, see how RAITHub would build this below.

This guide is for course creators outgrowing a hosted tool, training companies selling to employers, and EdTech founders whose product is the cohort itself. RAITHub's education work is PadhAI, an AI tutoring platform it built; RAITHub has not shipped a cohort course platform, so the cohort-specific parts below are engineering guidance, labelled that way. Vendor prices come from each vendor's own pricing page, checked on 2 October 2026.

What is the difference between a cohort-based course and a self-paced course?

A self-paced course is a library: a learner buys it and works through it whenever they like. A cohort course is an event: everyone starts together, meets live, and finishes by a date. That one difference changes most of the software.

Aspect	Self-paced	Cohort-based
Start date	Any time	Fixed; enrolment closes before it
Content release	All at once, or drip from each learner's purchase date	Unlocks by week for the whole group, from the cohort start date
Live sessions	Optional or none	Core: scheduled calls, recordings, attendance
Community	One forum for all buyers	A space per cohort, often with small groups inside it
Assignments	Self-checked quizzes	Deadlines, peer or instructor feedback
Capacity	Unlimited	Seat caps, waitlists, sometimes applications
Price and revenue	Lower price, many sales over time	Higher price, revenue in bursts around each launch
Certificates	On completion	On completion plus attendance or project criteria

What features does a cohort-based course platform need?

Seven, and the first four decide whether a cohort runs smoothly in week one:

• Cohorts as a first-class object. One course, many runs, each with its own start date, timezone, capacity, price and instructors.
• A schedule. Live sessions with calendar invites, shown in each learner's own timezone, with recordings attached afterwards.
• Relative release. Week 3 unlocks on day 14 of this cohort, not on a calendar date you retype for every run.
• Enrolment and payments. Seat caps that never oversell, waitlists, deposits or instalments, team purchases and refunds before the start date.
• Community. A space per cohort, with small breakout groups and instructor announcements.
• Assignments. Deadlines per cohort, submissions, feedback, and late or missed work visible to instructors.
• Certificates. Issued when completion rules are met. If employers will verify them, consider the 1EdTech Open Badges standard; version 3.0 credentials are digitally signed and compatible with the W3C Verifiable Credentials Data Model 2.0 (1EdTech: Open Badges).

Maven vs Circle vs Teachable vs Thinkific vs Kajabi: what do they cost?

They price in two ways: a share of every sale, or a monthly subscription plus a transaction fee on some plans. Figures below are from each vendor's pricing page; annual-billing prices are shown per month. Card processing fees usually apply on top.

Product	Pricing model (from the vendor)	Cohort-relevant notes
Maven	"Experts keep 90% of all sales," a 10% share (Maven for teachers)	Built around live courses "over multiple sessions"; Maven also brings its own marketplace audience
Circle	Professional $89, Business $199, Scale $419 a month billed annually; transaction fees 2%, 1% and 1% (Circle pricing)	Courses, events and live rooms; Professional includes 10 live hours and 100 attendees per event
Teachable	Starter $29, Builder $69, Growth $139 a month billed annually; Starter carries a 7.5% transaction fee, Builder and up 0% with teachable:pay (Teachable pricing)	Product limits of 5, 10 and 50; no cohort or live feature listed in its comparison table
Thinkific	Basic $40, Start $82, Grow $164 a month billed annually; Thinkific Payments at 2.9% (Thinkific pricing)	Communities on every plan; live Zoom sessions capped at 5 on Basic, unlimited from Start
Kajabi	Basic $143, Growth $199, Pro $399 a month billed annually; Kajabi Payments from 2.9% + $0.30 (Kajabi pricing)	Lists cohort courses on Growth and Pro; communities on all plans

This is not a ranking; each fits a different creator. Plans and limits change, so check the page on the day you decide.

Which is cheaper at my revenue: a revenue share or a subscription?

A share is cheap when sales are small and expensive when they grow; a subscription is the reverse. An illustration at $200,000 of course sales a year, using the list prices above and leaving out card processing, which you pay in every case:

Setup	Platform cost per year
Maven, 10% share	$20,000 (check whether processing is inside or on top of the share)
Teachable Builder, annual, 0% fee with teachable:pay	$828
Thinkific Start, annual	$984
Kajabi Growth, annual, with Kajabi Payments	$2,388
Circle Business, annual, plus its 1% transaction fee	$2,388 + $2,000 = $4,388

The lowest-cost line is not automatically the right choice. A revenue share often buys distribution: if Maven's marketplace sells seats you would not otherwise sell, the 10% may pay for itself. Subscriptions buy only software, so you bring every learner yourself.

Can I run a cohort course by combining tools instead of building a platform?

Yes, and for your first few cohorts you probably should. A common stack is a course host for content (Teachable or Thinkific), a community tool for the cohort space (Circle), a video tool for live sessions, a calendar invite per session, and the host's checkout or Stripe for payments. Setting that up is roughly 1 to 2 weeks of evenings for someone comfortable with SaaS tools, as an estimate.

The main risk is that enrolment lives in four places. A learner who pays is added to the course, but not to the community; a refund removes course access but leaves them in the calendar invites; a learner moved to the next cohort is in both. Automation tools patch this, until a step fails silently. When your team spends launch week reconciling member lists, the combined stack has stopped being free.

Buy, build or hire: which fits your cohort business?

Option	Examples	Choose this when	Outgrow it when
All-in-one, revenue share	Maven, at a 10% share	You are a solo expert, want an audience, and value launch support over control	The share exceeds what a subscription and your own marketing would cost
All-in-one, subscription	Kajabi Growth or Pro (cohort courses listed), Thinkific, Teachable	You have your own audience and a standard course shape	You need B2B accounts, local payment rails or custom learning flows
Combined tools (no-code)	Course host + Circle + video + Stripe	You want a better community or live experience than one tool gives	Enrolment sync breaks, or staff time on admin beats the cost of building
Custom build	Your own platform, quoted per scope	Cohorts are your product: you sell to companies, run many instructors, need local payments, or add AI between sessions	Rarely; the risk is building too early, before your course format is stable

For the wider decision, the no-code vs custom development guide covers the general trade-off, and the custom LMS vs Moodle guide covers open-source hosts.

When does a custom cohort platform pay for itself?

When one of these is true, and you have already run enough cohorts to know your format:

• You sell to companies. Employers buy seats in bulk, want their own admin view, progress reports per employee, single sign-on and invoices instead of card checkout. That is a multi-tenant product; the multi-tenant vs single-tenant guide explains the choice.
• Your learners pay through local rails. Card-first hosts may not take bKash in Bangladesh or the wallets your market uses. PadhAI integrates 9 payment gateways for exactly this reason.
• You run many instructors or a marketplace. Splitting revenue, scheduling many cohorts and paying instructors is a product of its own; the tutoring marketplace guide covers the mechanics.
• You want learning between sessions. An AI tutor that answers questions from your course material between live calls. PadhAI's Socratic tutor uses RAG (retrieval-augmented generation, which grounds answers in source material) and a 70/20/10 LLM router to keep cost per learner down; the AI tutor guide covers the design.
• Platform fees exceed a build. Compare three years of share or subscription fees with a build plus hosting and maintenance. The LMS development cost guide lists the drivers.

How do you model cohorts, seats and live sessions in the database?

Treat the course as content, the cohort as a dated run of it, and let the database refuse to oversell seats. A minimal PostgreSQL sketch written for this post:

CREATE TABLE cohort (
  id           uuid PRIMARY KEY,
  course_id    uuid NOT NULL REFERENCES course(id),
  starts_on    date NOT NULL,
  timezone     text NOT NULL,              -- 'Asia/Dhaka', 'America/New_York'
  capacity     int  NOT NULL CHECK (capacity > 0),
  seats_taken  int  NOT NULL DEFAULT 0,
  CHECK (seats_taken >= 0 AND seats_taken <= capacity)
);

CREATE TABLE enrolment (
  cohort_id   uuid NOT NULL REFERENCES cohort(id),
  user_id     uuid NOT NULL REFERENCES app_user(id),
  status      text NOT NULL CHECK (status IN ('active', 'refunded', 'transferred', 'completed')),
  PRIMARY KEY (cohort_id, user_id)
);

-- Weeks unlock relative to the cohort start, so every run reuses the same course.
CREATE TABLE module_release (
  course_id    uuid NOT NULL REFERENCES course(id),
  module_id    uuid NOT NULL REFERENCES module(id),
  unlock_day   int  NOT NULL CHECK (unlock_day >= 0),   -- 0, 7, 14 ...
  PRIMARY KEY (course_id, module_id)
);

CREATE TABLE live_session (
  id         uuid PRIMARY KEY,
  cohort_id  uuid NOT NULL REFERENCES cohort(id),
  starts_at  timestamptz NOT NULL,          -- an instant, never local time
  minutes    int NOT NULL CHECK (minutes > 0),
  recording_url text
);

-- Claim a seat atomically after payment is confirmed: zero rows means sold out.
UPDATE cohort
SET seats_taken = seats_taken + 1
WHERE id = $1 AND seats_taken < capacity
RETURNING id;

Run the seat claim and the enrolment insert in one transaction, and release the seat on refund. The CHECK constraint is the backstop: even a buggy code path cannot push seats past capacity. The same pattern stops stock overselling in shops; the oversell prevention guide compares the options.

Store session times as instants (timestamptz) and convert only for display. A small TypeScript helper:

export function sessionTimeFor(startsAtIso: string, timeZone: string): string {
  return new Intl.DateTimeFormat('en-GB', {
    timeZone,
    weekday: 'short',
    day: 'numeric',
    month: 'short',
    hour: '2-digit',
    minute: '2-digit',
    timeZoneName: 'short',
  }).format(new Date(startsAtIso))
}

// One session, two learners:
sessionTimeFor('2027-01-12T14:00:00Z', 'Asia/Dhaka')        // Tue 12 Jan, 20:00 GMT+6
sessionTimeFor('2027-01-12T14:00:00Z', 'America/New_York')  // Tue 12 Jan, 09:00 EST

Exact abbreviations in the output vary by runtime; the instant does not. That matters when a cohort spans Dhaka, London and New York, and the clocks change in two of them but not the third.

Why RAITHub for this

• Education work that shipped. PadhAI, built by RAITHub: 11 services (9 Node/TypeScript, 2 Python), a Socratic tutor with math verification and RAG, a 70/20/10 LLM router, and delivery across a PWA, WhatsApp and Telegram. See the EdTech industry page and the EdTech software development guide.
• Payments in many markets. PadhAI's 9 payment gateways, plus bKash, Nagad and SSLCommerz in TheSkinProof, the founder's own venture, and Stripe rent collection in PropDesk.
• Multi-tenant builds. BlockEstate, a multi-tenant listing and inquiry platform, shipped as an MVP in 6 weeks; the same tenant model fits companies buying cohort seats.
• QA first. PropDesk has 1,024 tests; TheSkinProof 750+. Enrolment, refunds and seat caps are the kind of logic that needs them.
• Honest scope. RAITHub has not built a cohort platform. Cohort scheduling, community and certificates would be new work, quoted as such.

When you don't need us

• You have not run a cohort yet. Run two or three on Maven, Kajabi or a combined stack first; your format will change, and software should follow it.
• You are a solo creator with your own audience. A subscription host costs less per year than a build costs per week.
• Your problem is marketing. A custom platform does not sell seats.
• You need a native iOS or Android app. RAITHub builds web apps and PWAs only; a PWA installs on learners' phones without an app store.
• You want developers placed in your team by the hour. RAITHub does not offer staff augmentation.

How RAITHub would build this

• Scope: courses, cohorts and relative module release; enrolment with seat caps, waitlists and refunds; payments on your rails, card or local.
• Live and community: a timezone-correct schedule with calendar invites and recordings, using an existing video provider rather than building video; a space per cohort.
• Learning: assignments with deadlines and feedback, completion rules, and certificates, with Open Badges if employers will verify them.
• Later releases: company accounts with seat bundles and reports, or an AI tutor grounded in your course material.

Timeline: a focused first release, one course format and one payment rail, is typically 4 to 6 weeks at fixed scope through MVP development. Company accounts, many instructors or several gateways add releases. The MVP cost estimator gives a first range for your feature list.

You receive: automated tests and CI, covering enrolment, refunds and seat caps; handover docs and runbooks for launching a new cohort; and full IP, under an NDA. We sign NDAs and DPAs and work inside your controls; production data stays in your own cloud account, and development uses synthetic data.

Next step: book the free 15-minute technical audit, then you get a written fixed quote. Bring your current stack, your cohort size and the one admin task that eats launch week.

Frequently asked questions

What is a cohort-based course platform?

It is software that runs a course as a group with a fixed start date: scheduled live sessions, content that unlocks week by week for the whole group, a community space, assignments with deadlines and a certificate at the end.

What is the difference between cohort-based and self-paced courses?

Self-paced learners start any time and work alone through recorded content. Cohort learners start together, meet live, keep to shared deadlines and finish by a date, which needs schedules, seat caps and per-cohort communities.

Which platforms support cohort-based courses?

Maven is built around live multi-session courses and keeps a 10% share of sales. Kajabi lists cohort courses on its Growth and Pro plans. Circle, Thinkific and Teachable cover community, live events or course hosting, and are often combined.

Is Maven or Kajabi cheaper for a cohort course?

It depends on revenue. At $200,000 a year, Maven's 10% share is $20,000, while Kajabi Growth billed annually is $2,388 plus payment fees. Maven's marketplace may sell seats you would not reach yourself, which can justify the difference.

When should I build a custom cohort course platform?

After you have run several cohorts and one of these holds: you sell seats to companies, learners pay through local payment rails, you run many instructors, you want an AI tutor between sessions, or platform fees exceed the cost of a build.

How long does it take to build a cohort course platform?

A focused first release with one course format and one payment rail typically takes 4 to 6 weeks at fixed scope with RAITHub. Company accounts, multiple instructors and more gateways come in later releases.