How to build an e-learning platform: architecture, features, and real costs

Most e-learning platform projects start with a reasonable idea and end with a 6-month delay and a video player that buffers in the demo. The engineering isn't magic, but there are a few decisions - mostly around video and state management - that will make or break your product.

This guide covers what you actually need to build, what it costs, and where most teams waste money.

What kind of platform are you building?

Before you write a single line of code, get clear on your model. The architecture differs significantly depending on which of these you're building:

Creator marketplace (like Udemy): Instructors create and sell courses. You take a revenue share. Needs creator tools, payout logic, and a content moderation workflow.

Corporate LMS: Companies buy seats to train employees. Needs SCORM/xAPI compliance, SSO integration, completion reports, and admin controls.

Subscription learning (like MasterClass): One library, monthly subscription. Simpler monetization, but premium content demands premium video quality and DRM.

Cohort-based learning (like Maven): Live sessions, cohorts that start and end together, community features, and peer accountability. Different scheduling and group management requirements.

Each model has a different build cost and technical complexity. Mixing models (say, subscriptions plus a creator marketplace) compounds both.

Core features: what you actually need in v1

Here's what matters in a first version. Everything else can wait.

Video hosting and delivery

This is the most expensive and most important piece. Get it wrong and nothing else matters - students will leave a platform that buffers before they'll leave a bad instructor.

You have two viable options:

Use a dedicated video platform: Mux, Cloudflare Stream, or Vimeo OTT handle transcoding, adaptive bitrate streaming, CDN distribution, and analytics. This costs $0.05-$0.15/minute of video hosted plus bandwidth. At 1,000 hours of video content, you're paying $3,000-$9,000/month.

Build your own: Store raw video in S3, transcode with AWS Elastic Transcoder or FFmpeg on EC2, serve via CloudFront. Lower per-unit cost at scale but significantly more infrastructure work. Only makes sense at 10,000+ active hours of content.

For most teams, Mux is the right answer. The engineering time you save is worth more than the hosting cost difference.

One feature that's easy to overlook: DRM (Digital Rights Management). If your content is premium, instructors will demand protection. Widevine (for Chrome/Android) and FairPlay (for Safari/iOS) are the two standards. Both require a key server and add 2-4 weeks of development.

Course progression engine

Students complete lessons, sections, and courses. Seems simple. In practice, it's a stateful system that needs to handle:

• Resume from where the student left off (per device, ideally)

• Prerequisites (can't start Module 3 until Module 2 is done)

• Completion thresholds (must watch 80% of a video to mark it complete, not just click through)

• Drip content release logic (content becomes available on a schedule, not all at once)

This is a database-heavy feature. You're tracking per-user, per-lesson state across potentially millions of rows. The schema design matters a lot here - many teams regret choosing the wrong data model at the start.

Quiz and assessment engine

Quizzes are table stakes. Every LMS has them. The implementation choice is whether to build from scratch or use a library. For most teams, building from scratch with a flexible JSON schema for question types (multiple choice, true/false, fill-in-the-blank, matching) is the right call. It takes 3-4 weeks and gives you full control.

If you need more complex assessments (randomized question banks, timed exams, proctoring), plan for 6-8 weeks and consider a third-party proctoring integration like Proctorio or Honorlock.

Payment processing

Stripe handles 90% of e-learning payment needs. The complexity comes from your business model:

• One-time course purchase: straightforward Stripe Checkout

• Subscriptions: Stripe Billing with trial periods, downgrades, and cancellation flows

• Creator payouts: Stripe Connect (marketplace payments with automatic revenue splitting)

Stripe Connect is where projects get delayed. The compliance requirements for payouts - identity verification, bank account validation, tax form collection - add 3-4 weeks to any marketplace build.

Student dashboard and course catalog

Students need to see their enrolled courses, progress, and next steps. Instructors need to see enrollment numbers and completion rates. This is mostly UI work - React components pulling from your progression API.

The course catalog needs search and filtering. At small scale (under 500 courses), client-side filtering is fine. Over 500, you need a search service - Algolia or Meilisearch work well here.

Features for phase 2

These are real features that real platforms need - just not in month one.

Certificates: Auto-generated PDFs when a student completes a course. Needs a PDF generation library (like Puppeteer) and a unique certificate ID for verification. Takes 2 weeks.

Mobile apps: React Native lets you share 70-80% of your logic with the web app. The hard part is offline video download - storing encrypted video files locally for airplane viewing. This adds 4-6 weeks.

Discussion forums: Per-course community. You can build lightweight (threaded comments with up-votes) or integrate an existing community platform like Discourse or Circle.

Live sessions: Video conferencing integration (Zoom, Daily.co, or Agora) for cohort-based learning. Add a scheduler, recording storage, and session replays.

Recommendation engine: Suggest courses based on what a student has completed. A simple content-based recommender (tags + completion data) can be built in 2-3 weeks. Collaborative filtering (what students like you also took) is a 4-6 week ML project.

SCORM/xAPI compliance: Required for corporate LMS that needs to track training in existing HR systems. This is a headache - SCORM is an old standard with quirky behavior. Budget 4-6 weeks if you need it.

Tech stack

This is what most well-built e-learning platforms use:

Frontend: Next.js (App Router) for fast page loads and SEO. React Native for mobile.

Backend: Node.js or Python (FastAPI). GraphQL or REST - both work, but GraphQL is better when you have complex nested data (courses > sections > lessons > progress).

Database: PostgreSQL for user data, course metadata, and progress. Redis for session management and caching active progress states.

Video: Mux for video hosting and delivery in v1.

Search: Algolia or Meilisearch for course catalog.

Payments: Stripe (Checkout for one-time, Billing for subscriptions, Connect for marketplaces).

Infrastructure: AWS or Vercel. Most teams start on Vercel for the frontend (serverless, easy deploys) and use AWS for backend services and video storage.

Cost breakdown

Here's an honest breakdown of what you'll spend:

MVP: $40,000-$80,000

This gets you: video hosting (Mux), course progression, quizzes, payments, student dashboard, and instructor content upload. No mobile app, no creator marketplace, no advanced analytics.

Timeline: 12-16 weeks with a team of 3-4 (1 frontend, 1 backend, 1 full-stack, 1 product).

Creator marketplace: $120,000-$250,000

Adds: instructor onboarding, Stripe Connect payouts, course review workflow, creator analytics dashboard, affiliate program, mobile apps, and a recommendation engine.

Timeline: 6-9 months with a team of 5-7.

Enterprise LMS: $250,000-$500,000+

Adds: SCORM/xAPI, SSO (SAML/OAuth), white-labeling, admin reporting suite, team management, bulk licensing, and custom integrations with HR systems like Workday or BambooHR.

Timeline: 9-15 months. Often requires a dedicated DevOps hire.

Ongoing operational costs

At 10,000 active students:

• Video hosting: $3,000-$8,000/month (depends on content library size and viewing hours)

• Infrastructure: $1,500-$3,000/month

• Third-party services (Stripe fees, Algolia, email): $500-$1,500/month

Total: $5,000-$12,500/month. Plan for this before you price your courses.

Where teams waste money

Building a recommendation engine in v1. You don't have enough data to make it work. Come back at 5,000 students.

Custom video player. The browsers and native players are good. The only reason to build custom is branded experiences with very specific UX requirements. Even then, open source players like Video.js are 90% of the way there.

Over-engineering the course content model. Teams spend weeks building a flexible CMS for course content when structured MDX files or a simple JSON schema would have shipped faster and worked just as well.

Skipping mobile from day one. Planning for mobile late means you end up rewriting shared business logic. Design your API and state management with mobile in mind from the start, even if you don't build the app until month 6.

Build vs. buy

If you have under 1,000 students and don't need custom workflows, use Teachable, Thinkific, or Kajabi. They're not cheap ($50-$400/month), but they're faster than building and handle payments, video, and email for you.

Build custom when:

• You need white-labeling for B2B clients

• Your monetization model doesn't fit standard tools (enterprise seat licensing, cohort pricing, custom checkout)

• You need deep integrations with your existing product or HR stack

• You're building a marketplace, not just hosting your own courses

• You have a content library over 500 hours and need full control of video costs

How to start

Week 1-2: Define your model (marketplace, LMS, subscription, cohort). Map the core student journey end-to-end. Identify any regulatory requirements (SCORM, HIPAA for healthcare training, etc.).

Week 3-4: Schema design. Get the course progression data model right before you build anything else. This is the hardest thing to change later.

Week 5-16: Build the MVP in this order: user auth, video upload and playback, course progression, payments, student dashboard. QA each before moving to the next.

After launch: Watch completion rates first. A course with 20% completion has a content problem, an onboarding problem, or a UX problem - all of which are fixable. A course with 80% completion is something people will pay more for and tell their colleagues about.

If you need help with the architecture or want a team to build it for you, we've shipped edtech products from MVP to scale and can tell you in the first call whether your model makes sense.