LMS builder: prototype the course player first

What an LMS has to hold

Before thinking about screens, sketch the records. Even a small training business ends up with most of these, and the relationships between them are where homemade systems go wrong.

Course: Title, summary, audience, estimated hours, and an ordered list of modules. Some courses are linear; others let learners pick modules in any order.
Module and lesson: Each lesson has a type (reading, video link, worksheet, quiz), an estimated time and an optional prerequisite.
Learner: A person with a name, an email, the courses they're enrolled on and their organisation if you sell to companies.
Enrolment: The link between a learner and a course, with a start date, a deadline and a status: not started, in progress, completed, expired.
Attempt and result: Each quiz attempt with its score, date and answers, so a trainer can see what people misunderstood rather than just a pass mark.
Certificate: Issued on completion, with a date and a reference number someone could check later.

Roles sit on top: learners see their own enrolments, instructors see their cohorts, and an administrator manages courses and people. Reporting for a client company usually means completion rates per team and a list of who is overdue.

What the prototype can show

The part worth testing early is the learner's journey. Does the course outline make sense? Do lessons feel the right length? Is it obvious what to do next after a quiz? A single-device prototype answers those questions well, because one person can sit with it and click through as a learner would.

A description that works: "An LMS prototype for a first-aid training company, from the learner's side. A dashboard with three enrolled courses and progress rings. A course page with modules and lessons, each marked done, current or locked. A lesson player with reading text, a worksheet download and a five-question check at the end that needs 80 per cent to unlock the next module. A progress page with quiz history and a printable certificate on completion. Sample learner and courses, labelled demo data. Save progress in the browser."

Anticode writes this as one app. Progress, quiz scores and the certificate state are kept in that browser, so you can work through the course over a few days and pick up where you left off. The app can produce the certificate as a file to download or open the print dialog. You can also ask for a separate instructor view filled with sample learners, to show a client what reporting would look like, as long as everyone understands those names are invented.

What a single-device prototype can't do

An Anticode app runs in a sandbox with no network, and for a learning system that rules out the core of the product:

No learner accounts. There's no sign-in, so the app can't tell one student from another.
No central record. Progress lives in the browser it was made in. A trainer can't see a learner's results, and a learner who switches from a laptop to a phone starts again.
No enrolment or payment. You can't sell a course place or open access after purchase inside the app.
No hosted video. The app can't load video files from elsewhere; it can link out to a lesson video in a new tab.
Public by link. A published app opens for anyone who has its address, so it isn't a place for paid course material you want to protect.
No standards. It doesn't import or export SCORM or xAPI packages, which corporate clients often ask for.

Where the real version lives

An existing course platform

If you sell courses to the public, a hosted course platform gives you accounts, payments, video hosting and certificates on day one. Use the prototype to decide the structure and lesson format, then rebuild it there. For marketing the course itself, a separate course website with an enquiry form is often enough.

A custom build from the Next.js export

When the learning logic is specific to you, for instance compliance training with its own rules for expiry and re-certification, the Next.js export gives a developer a TypeScript project with Postgres through Prisma, email sign-in links for customers, staff and admin roles, an admin area with two-factor sign-in, an audit log and row-level security in the database. Learner, enrolment and attempt tables still have to be designed and built; the export is the foundation, and the prototype is the specification. The prototype-to-production workflow covers that hand-over.

Questions people ask

Can I use a learning management system builder like this for a small pilot?

For one learner per device, yes. Several people can each run it on their own device, but nobody can see anyone else's progress, so collect results through the form.

Can the prototype play my course videos?

It can't load video from another site inside the app. It can link to each video so it opens in a new tab.

Can it issue certificates?

It can draw a certificate and offer it as a download or a print, but anyone could do the same, so it isn't proof of completion.

What should I test with the prototype?

Lesson length, the order of modules, how quizzes gate progress and whether learners always know what to do next.