Learning Management System (LMS)

Key Features

Dedicated Frappe app (`bench get-app` installable) with first-class DocTypes — `Course`, `Course Lesson`, `Quiz`, `Course Enrollment`, `Assessment Result`, `Course Certificate` — not stock-form customizations

Drag-orderable lesson builder using child-table `idx` sequencing, with mixed content blocks (video URL, rich text, file attachments, embedded quiz)

Quiz engine with single/multiple-choice, true/false, and numeric questions, per-question weighting, randomized ordering, and configurable attempt limits

Server-side grading in whitelisted methods (`@frappe.whitelist()`) so pass/fail can never be tampered with client-side; `Assessment Result.on_submit` recomputes the weighted score

Automatic certificate issuance via `hooks.py` `doc_events` when the pass threshold is met, rendered to PDF from a Print Format with a QR verification link and public whitelisted verifier endpoint

Batch/cohort enrollment with `Course Enrollment` records, seat caps, and open/close enrollment windows enforced by `scheduler_events`

Role Profiles and `role_profile`-scoped permissions for Student, Instructor, and Program Admin, plus User Permissions restricting instructors to their own batches

Progress tracking at the lesson grain (`Lesson Progress`) driving completion percentage, next-lesson gating, and a per-learner dashboard

Frappe REST API surface (`/api/resource/*`) plus custom whitelisted methods for enrollment, quiz submission, and progress, enabling a headless or mobile front end

Scheduled drip-content release and deadline/renewal reminders through the Notification framework and daily/hourly scheduler jobs

Learner-facing delivery as either a Frappe Web Portal (Jinja `www/` pages + Web Forms) or a decoupled SPA against the API — chosen at scoping

Query Reports and Dashboard Charts for completion rates, average scores, cohort throughput, and time-to-complete, sourced from the LMS DoctTypes

Time-boxed / expiring certifications with automated expiry and renewal workflow for compliance-driven training

Client Scripts for in-form UX (reveal next lesson on completion, live quiz validation) and Notification-framework email/system alerts on enrollment, grading, and certification

Built and tested for Frappe/ERPNext v15 and v16 with a clean migration path via `bench migrate` and app patches

Built to order, done for you

No DIY setup — a working app, built, installed and supported by ECOSIRE.

You order

Start with a one-time build price. We scope it with you at kickoff.

We build & install

ECOSIRE builds, configures and installs it on your ERPNext.

Go live + support

You go live in about 2–4 weeks, with a post-launch support window.

About this Product

Training providers, ed-tech startups, and corporate L&D teams outgrow spreadsheets and disconnected video tools fast: they need to author structured courses, gate progression on graded assessments, issue verifiable certificates, and prove completion to auditors or clients — all tied to the same contacts, invoices, and reporting they already run in ERPNext. ERPNext core has no learning surface at all (the community frappe/lms app is a separate product with its own opinions), so teams end up stitching together an external LMS that never shares a customer record, a payment, or a report with their operational system. That integration gap is exactly where this build lives.

ECOSIRE builds a proper Frappe app — a versioned, bench get-app-installable module with its own DocTypes rather than customizations bolted onto stock forms. The data model is modeled as first-class DocTypes: Course, Course Lesson (child ordering by idx), Quiz and Quiz Question, Course Enrollment, Lesson Progress, Assessment Result, and Course Certificate. Business logic runs where Frappe expects it: hooks.py doc_events (for example Assessment Result.on_submit) recompute a learner's weighted grade and, when the pass threshold is met, insert the Course Certificate and fire a notification. Server-side scoring and eligibility checks live in whitelisted methods (@frappe.whitelist()) so a browser can never award itself a pass; client scripts handle the in-form UX like revealing the next lesson only after the current one is marked complete.

Access and multi-audience separation are handled with Frappe's permission engine — Role Profiles and role_profile-driven permissions for Student, Instructor, and Program Admin, plus User Permissions to scope instructors to their own batches. The learner-facing experience is delivered either as a Frappe Web Portal (Jinja www/ pages and Web Forms) or as a headless front end consuming the Frappe REST API (/api/resource/Course, /api/method/...) and your whitelisted enrollment and quiz-submission endpoints — you choose during scoping. Scheduled jobs (scheduler_events — hourly/daily) drive cohort lifecycle automation: opening and closing batch enrollment windows, sending drip-lesson and deadline reminders via the Notification framework, and expiring or renewing time-boxed certifications. Certificates render from a Print Format to PDF with a QR/verification link backed by a public whitelisted verifier.

Because this is build-to-order, you are not downloading a fixed marketplace app and hoping it fits. We start with a scoping call to map your course structure, assessment rules, certification logic, and who needs to see what. We then build and configure the app against Frappe/ERPNext v15 or v16, validate it with you on a staging bench through UAT, and cut over to production with a rollback plan. Typical delivery is 2–4 weeks from confirmed scope, and you receive the full source in a Git repository you own, so nothing about the system is locked away from your own engineers.

What you get

Installable source code for your version of the LMS app, packaged as a standard Frappe app

Installation and configuration on your bench, including Role Profiles, scheduler events, and Print Formats

Technical documentation: DocType reference, hooks/`doc_events` map, whitelisted API endpoints, and permission model

End-user and instructor guide plus a live training session for your admins and course authors

Post-go-live support window for defect fixes and configuration questions

UAT on a staging bench with a signed-off test plan, plus a documented rollback plan for production cutover

Git repository handover with full commit history so your engineers own and can extend the code

Data setup assistance: initial course/quiz seed import and a sample cohort for validation

Who this is for

Training provider / course academy

Runs paid instructor-led and self-paced courses and needs cohort enrollment, graded assessments, and verifiable certificates tied to the same ERPNext where invoicing and student contacts already live.

Ed-tech startup founder

Wants a self-hostable, source-owned LMS on Frappe with a REST API for a custom or mobile front end, avoiding per-seat SaaS pricing while keeping full control of the data model.

Corporate L&D / compliance manager

Needs to assign mandatory training by role, track completion at the lesson level, and issue time-boxed certifications with automated renewal reminders for audit evidence.

ERPNext administrator / internal engineer

Owns an existing ERPNext deployment and wants a clean, `bench`-installable app with documented DocTypes and hooks that migrates cleanly on v15/v16 rather than fragile form hacks.

How Learning Management System (LMS) Compares

Criterion	ECOSIRE	Custom Build	Competitor
Fit to your curriculum & grading rules	Modeled exactly to your courses, weighting, and certification logic	Fully custom but you specify and maintain everything	Fixed feature set; you adapt to its assumptions
ERPNext integration	Same site, shared users/contacts/reporting, clean `bench migrate`	Depends on your team's Frappe depth	Often a separate product with loose coupling
Source ownership	Full Git repo handover, yours to extend	You own it but built it from zero	Vendor-controlled; limited to their roadmap
Assessment & certificate integrity	Server-side grading in whitelisted methods + hook-issued certificates	Only as strong as you build it	Varies; may score client-side
Time to production	Typically 2–4 weeks from confirmed scope	Months, plus hiring/ramp risk	Fast to install, slow to bend to your needs
API / headless front end	REST + custom whitelisted methods, portal or SPA	Whatever you choose to build	Limited to what the app exposes
Support & accountability	Post-go-live window + optional retainer, single vendor	Your team owns all defects	Community/vendor tickets, no customization
Version support (v15/v16)	Built and tested on both, upgrade path quotable	You track and test upgrades	Depends on maintainer's release cadence

Frequently Asked Questions about Learning Management System (LMS)

Is this a ready-made app I can download and install today?

No. This is a build-to-order engagement. ECOSIRE builds the LMS to your curriculum, assessment rules, and certification logic, then installs and supports it. It is not an existing Frappe Cloud Marketplace download, so there is no instant-download link.

How long does delivery take?

Typical delivery is 2–4 weeks from confirmed scope. The timeline starts once we've agreed on your course structure, grading rules, roles, and front-end choice during scoping. Larger catalogs, headless front ends, or complex certification/renewal logic can extend it — we confirm the estimate in writing before starting.

How is this different from the community frappe/lms app?

The community app is a fixed, opinionated product. We build an app shaped to your requirements — your DocType fields, grading formulas, permission model, certificate design, and API. You own the source in Git and can extend it, rather than working around someone else's assumptions.

Does it work with our existing ERPNext, and which versions?

Yes. It installs as a standard Frappe app alongside ERPNext and shares the same site, users, and contacts. We build and test for Frappe/ERPNext v15 and v16, with a clean `bench migrate` path. Tell us your exact version at scoping.

What about support and updates after go-live?

Every engagement includes a post-go-live support window for defect fixes and configuration questions. Because you receive the full Git repository, your own engineers can maintain it, and we can quote an ongoing support/enhancement retainer or handle version upgrades (v15→v16) as a separate scope.

Can we run a custom or mobile front end instead of the Frappe portal?

Yes. The LMS exposes the Frappe REST API plus custom whitelisted methods for enrollment, quiz submission, and progress, so you can build a headless React/Next.js or mobile client. We decide between a Frappe Web Portal and a decoupled front end during scoping.

How are quiz scores and certificates kept tamper-proof?

All grading and pass/fail decisions run server-side in whitelisted methods and `on_submit` doc events — the browser never computes its own result. Certificate issuance is triggered by a hook only when the recorded score meets the threshold, and each certificate carries a QR link to a public verification endpoint.

Learning Management System (LMS)

A Frappe-native Learning Management System for courses, quizzes, certifications, and student progress tracking, built to your curriculum on ERPNext. ECOSIRE designs, installs, and supports it as a build-to-order engagement.

Drag-orderable lesson builder using child-table `idx` sequencing, with mixed content blocks (video URL, rich text, file attachments, embedded quiz)

Quiz engine with single/multiple-choice, true/false, and numeric questions, per-question weighting, randomized ordering, and configurable attempt limits

Server-side grading in whitelisted methods (`@frappe.whitelist()`) so pass/fail can never be tampered with client-side; `Assessment Result.on_submit` recomputes the weighted score

What is Learning Management System (LMS)?

Key Features