Skip to main content

Tangible LMS

Tangible LMS is Tangible's in-house LMS plugin.

Resources

Planning Calls

Intro​

We have a client interested in helping to fund our very own LMS (https://paragonpetschool.com)! We need to think about basic system architecture and get a rough idea of scope so that we can make a proposal to the client. The LMS needs to support the following:

  • Editing and display of courses with nested items/folders of items
  • Visibility control for course items based on enrollment
  • Visibility control for course items based on progress
  • Eventual support for Common Cartridge V4 import/export (we'll need to give 1edtech money before they'll let us see the v4 spec)
  • Integration with Tangible Quizzes, which will be a separate plugin/system, which is currently being designed. Quizzes will be supported as - items in Tangible LMS courses.
  • Progress tracking, designed for efficient querying for completion percentage and enrollment status (bool)/progress status (null/not started, in progress, completed):
  • By User ID or list of User IDs
  • By Course ID
  • By item ID
  • Support for course retakes without complete loss of historical data
  • Support for student -> teacher relationships, which at its most granular should be addressable per course enrollment
  • Integration with popular video player APIs for step videos (beginning with Vimeo)
  • Integration with WooCommerce for course enrollment (built as extensibly as possible for future integrations with other e-commerce solutions, - efficient bulk background enrollment)

We don't have a clear picture of what this system will look like in the granular details yet, but I'd like to start discussions so that we can come up with a general plan for what schema/systems we'll need to build to meet Paragon's needs and to be flexible to eventually accommodating other common patterns

Other relevant standard to consider:

Feature scope from April 2022:​

Overview​

We got our start building LMS sites and plugins around other people’s tech. We’ve found that the way current LMS systems are built makes them very inflexible and gives us a feeling that we constantly have to “hack” the system to get it to match everyone's business models. We’d like to start putting some thought into how we can create a more abstracted, universal, simple system that doesn’t feel as though we need to fight it every step of the way.

On the market right now, you have to choose between something very simple but perhaps too barebones in a business context (like https://wpcomplete.co/) or something that tries to take over membership, e-commerce, social, etc. and leaves your site a bloated mess.

Inspiration​

Among the most popular learning management systems by market share (source), they mention Moodle, an older but established LMS in academia; the Canvas platform is an up-and-coming provider seeing increasing adoption; Blackboard is another such service. There are concepts/approaches that are relevant to building an LMS (builder) on WordPress.

The UI of Travitor is among the more impressive options. Pluralsight has some interesting ideas, particularly around reporting back to superiors.

Key areas:​

  • Robust CEU functionality, with easy verification/sharing
  • Robust cohort functionality (strong overlap with drip)
  • Competencies (taxonomies)
  • Spaced repetition
  • Thoughtful, limited gamification (we need to have it as a “checkbox” of features people want to see, but it’s typically not implemented - effectively and hardly worth the investment in 90%+ cases so we need to be careful)
  • 1:1 & small group coaching, with live video
  • Scheduling/booking
  • Webinar-style live classes
  • Integration with SIS (Student Information Systems)
  • Import/Export in Common Cartridge
  • Native LRS compatibility (and functionality?)
  • Corporate/group sales/reporting (accountability to managers)
  • Robust time-based functionality (dripping on a per user, per group, per cohort, per course, etc. level)
  • Drip topics (not just lessons)
  • Drip entire courses for users in a group (without buying another plugin)
  • Pause/re-start drip upon subscription payment fail/re-start
  • Preview upcoming drip content (e.g. in a widget)
  • Allow show/hide upcoming dripped content in course table of contents (great for hinting at what's coming, or just surprising students)
  • Override drip for a specific user
  • Offer dripped version and instant full access version of same course (without duplicating content)
  • Unique specific date drip schedules for different course cohorts (great for live courses launched multiple times a year)
  • High level calendar overview of all drip content for easy drag-and-drop schedule changes (instead of manually editing each lesson)
  • Deep CRM event integration (via WP Fusion or natively)
  • Focus on scalability & high concurrency
  • Make it easy to offload intensive operations like reporting, PDF generation, etc.
  • Graceful handling of changes to courses vs existing progress (maybe something like the waybook minor vs major change system, where you can - decide if a change ought to impact existing user progress or not)
  • Think about how the system might be used in hybrid or fully in-person settings (EI’s presentation mode or “jackbox” style systems like Kahoot - where presenter presents a question/challenge that is then answered on a client app)
  • Mobile-first quiz system with maximal coverage of QTI standard.
  • Robust security features for those that need to meet standards for certification, such as enforcing minimum or maximum time limits and - preventing people from running out the timer while AFK or doing other stuff on their computer/phone. Enforce video watching, etc.
  • Forums/DMs/group discussions
  • Controlled customizations (branches) for cohorts/groups/users. No structural changes without fork
  • Changes to courses major or minor, option to require re-completion

MVP​

For an MVP, I think the big problems we keep seeing that seem endemic to existing architectures that we would not want to introduce in how we do things are:

  • No good native way to handle changes in ongoing courses (if you add or remove a step, what happens to people who are ahead of that step? Do we backfill? Do they have to go back and complete that? I kind of like the concept of minor vs major changes in Waybook in the attached screenshot)
  • People running cohorts often end up having to create many copies of the same course to accomplish basic things -Hybrid courses (courses with live components) are often super clunky to integrate, especially when they overlap with the cohort issues above -Running reports is a nightmare for performance, and everyone always wants more reports on both the backend and frontend (for group leaders) than can be safely implemented without tanking performance. We need a data structure that makes reporting queries manageable. We need to be more ready for admin-facing reports that give insight into course and quiz quality, as that is the main blind spot in existing reports. For instance, an admin would want to know that 95% of users are failing a given quiz question, since that might indicate an issue with the quiz question.
  • Quiz processing is one of the primary performance killers, and we increasingly see people with enormous question sets. For example, test prep use cases often work with question banks with 4-5 figures worth of questions of which a random subset are pulled and shown. -Enrolment processes and permission checks often lead to performance issues, especially where things need to happen in bulk. For example, adding a course to an existing membership plan that has 10K students in it requires checking whether each of the 10K students is currently enrolled or not and adding them to the course if they are not. It's generally more efficient to do something like adding that membership to the list of memberships that can access the course and running the permissions check that way at the time a student visits the course.
  • Some LMS systems don't make use of transients or any other caching techniques, so they don't wind up benefitting from Redis nearly as much as they could. Since Redis is on by default on TXP, we should lean heavily into using it everywhere it makes sense to. -There are issues with race conditions in the LD codebase, we should watch out for those -The way WP role queries work doesn't scale well. In LD's group management interface, you can select a group leader from a list of all users with the role group leader, and that stops working past a certain number of users due to the lookup time for all users of that role. Titus fixed it somehow, and if we have any similar situations we may need to include the fix (perhaps as a toggle option)
  • Many people want to do things like "micro-learning" or have lessons that are kind of outside of a course structure. Alternatively they want to plot different paths through the same content, or have a sort of choose-your-own-adventure type path through the available content. This also connects with people increasingly trying to do "adaptive" or personalize learning journeys with AI (though AI is often overkill for what ends up being a simple recommendation algo or just showing more content in the category a student is weak at). It's been nearly impossible to implement these kinds of scenarios in an easy to manage way due to rigid course structures in other systems. Unfortunately Common Cartridge tends to follow the more traditional course structure, so it may be a challenge to maintain compatibility while allowing for more free-form learning.
  • Enrolment being binary has been a big pain in our butts. Many sites really have 3 states: unenrolled, allowed to enroll, and enrolled. While it's possible to "emulate" the middle option in some ways, it can be a challenge. The reason for the middle state is that if you have a large library of say 100 courses, and you have a membership that gives access to all 100, you as a student probably aren't actually going to take all 100 and are only going to care about a small handful of them. In existing systems, enrolling in a course puts it into the list of active courses and makes it seem like a "to-do" item on your dashboard, potentially even with automation to nudge you to keep going. You wouldn't want the system to look like you are expected to take all 100 courses and would only want the ones you actively choose to take to count as full enrollment rather than just the option to enroll.
  • Everyone wants social learning, and nobody does it right. This shouldn't be part of the core LMS, but we may just want to think about where these kinds of features would need to hook in to make sure we architect things in a way that makes it easy to add relevant social features in the course UI (these often have to be segregated by cohort, student-teacher relationship, etc.). SureDash, Fluent Community, Circle.so and Disco should be looked at to see how this might look.
  • We should have a non-stupid way to do end of course surveys, especially when they're required for completion People often want to send notifications (email or otherwise) to nudge people to keep at it, usually with conditions like "if the user is more than halfway through the course but hasn't logged in for a week, send them a nudge". This often winds up being hard to set up in a way that is easy for the user to manage. Even if we don't handle this directly, we should think about how to make this easier on people. Perhaps looking at the insane way DuoLingo does this for inspiration about the most aggressive possible implementation of nudging would need to be able to accomplish would be the move.

Paragon Usecase​

To stay productive on something of such a large scope, I suggest that either prior to or during the meeting we triage the various items we've brought up into 3 buckets:

  • Important for Paragon (part of the initial scope)
  • Important to think about in the initial architecture (not in scope for Paragon, but might impact the approach we take for Paragon in order to be ready to tackle without rethinking the whole architecture)
  • Problems for future us (either too complex or far future to worry about now, or low architectural implications)