Frappe Learning (frappe/lms): A Self-Hosted LMS Built on the Frappe Framework

What Frappe Learning is, and the Moodle comparison that started it

The README is unusually direct about the origin. The Frappe team wanted a learning system for Mon.School, a project for FOSS United, evaluated Moodle, and concluded that "the forms were unnecessarily lengthy and the UI was confusing." Frappe Learning is the result of that reaction. It is a course platform, not a general-purpose training suite, and the design goal stated in the README is that "anyone can use to launch a course of their own."

The audience follows from that. A small team or an individual instructor who wants to publish a structured course, run a cohort with live sessions, grade quizzes and assignments, and issue certificates can do all of it inside one application. An organisation with an existing compliance training catalogue, a mandated SCORM package library, or a need to interoperate with third-party content players is a different audience, and the README does not claim to serve it.

The stack is Frappe Framework for the backend and Frappe UI, a Vue-based component library, for the interface. The repository confirms this: the top level holds a lms/ Python package, a frontend/ directory, and a frappe-ui submodule. The primary language listed for the repository is TypeScript, which reflects how much of the visible product is the Vue frontend rather than the server code.

The three-level course hierarchy and the batch model behind it

The organising idea is stated plainly in the key features: a course contains chapters, and chapters contain lessons. That is the whole content model. The README's justification is contextual rather than technical: "the context of the lesson is set by the chapter." If you have used an LMS where every lesson floats at the same level and ordering is a manual chore, this is the difference you feel first.

Batches sit alongside the content hierarchy rather than inside it. A batch groups learners around a course and a duration, which is what makes live classes and certificates meaningful: a batch is the cohort, the course is the material. Live classes are created for a batch from inside the app and, according to the README, use Zoom. Learners see the list of sessions attached to their batch.

Assessment is split into quizzes and assignments. Quiz questions can be single-choice, multiple-choice, or open ended. Assignments are submitted as PDFs or documents. Certificates come from a built-in template, and the README says you can supply your own template instead. Note what is absent from that list: there is no mention of question banks, randomised question pools, proctoring, or prerequisite gating between chapters. Those are reasonable things to want, and the documentation does not describe them.

Installing Frappe Learning with Docker and logging in for the first time

The README gives two paths: managed hosting on Frappe Cloud, or self-hosting. The self-hosting instructions start with a single download and a deploy command. The script is described as producing a production-ready instance "in about 5 minutes."

wget https://frappe.io/easy-install.py
python3 ./easy-install.py deploy \
    --project=learning_prod_setup \
    --email=your_email.example.com \
    --image=ghcr.io/frappe/lms \
    --version=stable \
    --app=lms \
    --sitename subdomain.domain.tld

Replace the email and the sitename with your own values. The README warns about one failure mode explicitly: a 404 Page Not Found error usually means DNS is not pointing at the server. On a public server the A record must resolve to the machine's IP; locally you map the domain to 127.0.0.1 in /etc/hosts.

For development, the Docker route downloads a compose file and an init script into an empty directory, then starts the stack.

mkdir frappe-learning
cd frappe-learning
wget -O docker-compose.yml https://raw.githubusercontent.com/frappe/lms/develop/docker/docker-compose.yml
wget -O init.sh https://raw.githubusercontent.com/frappe/lms/develop/docker/init.sh
docker compose up -d

The README states the site then appears at http://lms.localhost:8000/lms with the default credentials Administrator / admin. The repository also ships docker-installation.md and bench-installation.md at the top level, so the written setup guidance is not confined to the README. The bench path is the more involved one: install bench, create a site, add it to hosts, fetch frappe/payments, fetch frappe/lms, then install the app on the site.

Version pairing is the constraint that will bite you first

The most concrete limitation is in pyproject.toml, not in the feature list. The package declares requires-python ">=3.14,<3.15" and a Frappe dependency of ">=17.0.0-dev,<18.0.0". The frontend package.json requires Node ">=24". Those are narrow windows. A server running Python 3.12 or Node 20 will not satisfy them, and the Frappe major version is pinned to the development line of 17, which means you are tracking a moving target rather than a settled release.

The release history reinforces the point. The recent releases listed are asset bundles tagged version-16, version-16-hotfix and version-15-hotfix, all dated 2026-09-16. Asset versioning is not the same as an application release, and the README does not describe a versioning or upgrade policy for the application itself. If you need to know what a supported upgrade path looks like before you put a course catalogue on it, that answer is not in the README.

There is a second, quieter limitation. The README's motivation is simplicity, and simplicity in an LMS usually means the extension surface is small. Nothing in the README describes a plugin API, a webhook system, or an LTI integration. The repository does not list any such module at the top level either. If your requirement is to plug Frappe Learning into an existing student information system, the documentation is silent on how.

Frappe Learning versus Moodle: two different centres of gravity

The obvious alternative is Moodle, and the README names it as the tool the team evaluated and rejected. The difference is architectural, not cosmetic. Moodle is a plugin platform: the core is deliberately thin and the feature set is assembled from modules, activities and question types contributed over two decades. That is why its administrative surface is large, and it is also why it can import SCORM packages, run a question bank with randomised variants, and satisfy institutional procurement checklists.

Frappe Learning inverts the priority. It is an application on top of a general web framework, with a fixed set of features: courses, chapters, lessons, batches, Zoom classes, quizzes, assignments, certificates. You get a coherent authoring experience and a modern Vue interface, and you give up the breadth of the plugin ecosystem. Neither choice is wrong. They answer different questions. If your evaluation criteria are content portability standards and third-party activity types, Moodle wins on features the README does not claim. If your criteria are how long it takes an instructor to publish a chapter, the README's entire motivation is that this is where Moodle lost.

A second alternative is not a competitor at all: if you already run ERPNext, Frappe Learning shares the same framework and deployment model, which changes the integration calculus entirely. The repository does not document an ERPNext integration, so treat that as a same-stack convenience rather than a supported feature until you verify it.

Licence, maintenance and what an upgrade actually costs

Frappe Learning is AGPL-3.0, and package.json records the licence as AGPL-3.0-or-later. The practical consequence of AGPL for a hosted service is the network clause: users interacting with a modified version over a network are entitled to the corresponding source. If you plan to modify Frappe Learning and offer it as a service, that obligation is the thing to read carefully with your own counsel. Nothing here is legal advice, and the repository's license.txt is the authoritative text.

The maintenance picture is healthy by the only measure available: the repository is not archived, and the last push was on 2026-09-23, one day before the date used for this assessment. That is a current codebase, and the release tags from 2026-09-16 show asset builds landing in the same week.

Upgrade cost is where the version pins return. Because pyproject.toml targets the Frappe 17 development line, upgrading Frappe means moving Frappe Learning with it, and the frontend requires Node 24 or newer to build. A self-hosted deployment therefore carries a runtime upgrade obligation on three fronts: Python, Node and Frappe itself. The managed Frappe Cloud route exists precisely to move that obligation elsewhere, and the README describes it as covering installation, setup, upgrades, monitoring and maintenance. Whether you want that trade is the real deployment decision.

Editorial conclusion

Adopt Frappe Learning if you already run Frappe or ERPNext, or if you want a course platform where the authoring surface is a handful of forms rather than a plugin administration console. Do not adopt it if you need SCORM or xAPI content import, an offline mobile client, or a stack you can host without Python, MariaDB, Redis and Docker knowledge; none of those appear in the README or the repository files. Before committing, verify the version pairing in pyproject.toml against the Frappe release you can actually run, and open the site once at /lms to confirm the frontend build resolved.

Frequently asked questions

Official sources

1. frappe/lms on GitHub
2. License: AGPL-3.0
3. Project website
4. README
5. Releases