Courses & Packages

Building a course from units, the four e-learning standards supported, and versioning courses over time.

How eLearning Works

The learning module runs standards-based e-learning: you upload course content, assign it to people, and it records what they did.

Where to find it

Architect Panel → eLearning:

Courses & Assignments — the course console — courses, units, assignments
Learner Records — a learner’s registration against a package
Course Attempts — each attempt at a package
Course Sessions — individual launches
Learning Objectives — objective-level results

The layers

A package is content you upload — a SCORM, xAPI or cmi5 package produced by an authoring tool.
A course is what a learner is assigned. It contains one or more units, each of which is a package or a link.
An assignment says who should do a course, by when, and how often it repeats.
An enrolment is one learner on one course for one cycle.
A registration is that learner against one package, holding the score and status.
Attempts, sessions, interactions and objectives are the detail underneath.

The distinction between a course and a package is the one to hold on to. A course is yours; a package is the content.

Why a course is more than a package

A course can combine several packages with a reading link and a document, in a defined order, with a rule about what counts as complete. A single package cannot express any of that.

Even for one piece of content, wrapping it in a course gives you versioning, expiry, certificates and assignment — none of which a bare package has.

Results are recorded, not asserted

The platform records what the content reports: score, completion, success, time, and where the learner got to. It does not decide those things — the package does, and the package was built by whoever made it.

That distinction matters for anything you are relying on for compliance.

Detail down to the question

Where a package reports it, individual interactions and objectives are stored — the question, the learner’s answer, the correct answer, whether it was right, and how long it took.

Most organisations never look at this, and it is the most useful data in the module.

What it does not do

Sequencing inside a package remains the package’s job. The platform sequences units within a course; it does not implement IMS Simple Sequencing or cmi5 block sequencing.

Start with one course

Upload one package, build a course around it, assign it to yourself, complete it, and look at the record. That hour teaches more than any amount of configuration planning.

Worked example

An organisation runs annual information-security training as one course with three units — a SCORM module, a policy document and an assessment package — completed in order, valid for twelve months, assigned to everybody with a thirty-day due window.

Recommendations

Wrap even a single package in a course for versioning and expiry.
Remember results come from the content, not the platform.
Look at the interaction detail — it is the best data here.
Run one course end to end before designing a programme.

Supported Standards

Four standards are supported, and the choice affects what you can report on.

Where to find it

Architect Panel → eLearning:

Courses & Assignments — the course console — courses, units, assignments
Learner Records — a learner’s registration against a package
Course Attempts — each attempt at a package
Course Sessions — individual launches
Learning Objectives — objective-level results

SCORM 1.2

The oldest and still the most common. Every authoring tool produces it and it works everywhere.

Its limits are real: a simple pass/fail and score model, limited objective support, and a single completion status. For "did they finish the module" it is entirely adequate.

SCORM 2004

Separates completion from success — a learner can finish a module and fail it, which SCORM 1.2 conflates. It also handles objectives properly and supports a scaled score.

If your content tool offers it and you care about pass rates rather than completion rates, prefer it.

xAPI

Statements rather than a session — an actor, a verb and an object, recorded as things happen. It can record learning that is not a course at all: a document read, a task performed, an event attended.

More flexible and correspondingly less structured. What you can report depends entirely on what the content chooses to send.

cmi5

xAPI with the structure put back — a defined launch, defined verbs and a course structure the platform understands. In principle the best of both.

Support in authoring tools is thinner than for SCORM, so it is worth confirming your supplier actually produces it before standardising on it.

Which to ask for

SCORM 1.2 if you just need completion and it must work.
SCORM 2004 if pass and fail are different things to you.
cmi5 if your supplier genuinely supports it.
xAPI for learning that is not a packaged course.

Do not mix without a reason

Reporting across standards is harder than reporting within one, because the same idea is expressed differently. Pick one for your main catalogue and use the others where they earn it.

Ask before you buy

Content suppliers state the standard, and it is much easier to specify it in a purchase than to convert afterwards. Ask for the standard and version, and test one package before committing to a library.

Worked example

An organisation standardised on SCORM 2004 for its compliance catalogue, because it needed to distinguish learners who completed a module from those who passed the assessment. One supplier could only produce SCORM 1.2, which was accepted for two non-assessed modules.

Recommendations

SCORM 2004 where pass and fail differ.
Confirm cmi5 support with your supplier before standardising.
One standard for the main catalogue.
Test a package before buying a library.

Adding a Package

A package is uploaded content. The platform reads its manifest and registers what it finds.

Where to find it

Architect Panel → eLearning:

Courses & Assignments — the course console — courses, units, assignments
Learner Records — a learner’s registration against a package
Course Attempts — each attempt at a package
Course Sessions — individual launches
Learning Objectives — objective-level results

What is read from the package

The standard and version it declares.
The launch point — the file that starts it.
Its identifier, and for xAPI and cmi5 the activity identifier.
Mastery score, scaled passing score and completion threshold where declared.
Maximum time allowed and the move-on rule.
The structure — the parts inside it.

Those values come from the content, not from you. If the pass mark is wrong, it is wrong in the package.

Check the pass mark before assigning

The single most valuable check. A package with no mastery score, or one set to zero, passes everybody — and you will not find out from the completion report, because everybody completed.

Test it as a learner

Properly, on a real device:

Launch it and confirm it starts.
Get part way and leave. Come back and confirm it resumed.
Complete it correctly and confirm the pass is recorded.
Complete it incorrectly and confirm the failure is recorded.

The third and fourth are where problems appear. A package that records completion but never records a score is common, and it means your pass rate is meaningless.

Test resuming specifically

Learners do not finish in one sitting. A package that does not save its position produces learners who restart repeatedly and eventually stop trying.

Check it on a phone

Much e-learning content is built and tested on desktops and used on phones. Confirm it is usable on a small screen before assigning it to a workforce.

Keep the source

The original package file, from the supplier, somewhere you can find it. You will need it to re-upload, to test an upgrade, or to prove what was delivered.

Record what you tested

Which package, which version, what you checked and when. For compliance training this is part of the evidence that the training was fit for purpose.

Worked example

An organisation tests every package by completing it correctly and incorrectly on a phone, with a deliberate mid-course exit to confirm it resumes. One supplier’s package recorded completion but no score; it was returned rather than assigned to eight hundred people.

Recommendations

Check the pass mark before assigning anything.
Test a fail, not only a pass.
Test resuming and test on a phone.
Keep the source file and a note of what you tested.

Building a Course

A course is a container of units with rules about order and completion.

Where to find it

Architect Panel → eLearning:

Courses & Assignments — the course console — courses, units, assignments
Learner Records — a learner’s registration against a package
Course Attempts — each attempt at a package
Course Sessions — individual launches
Learning Objectives — objective-level results

Units

Each unit is either a package or a link, with a name, description, order, and two flags: whether it is required and whether it gates the next unit.

A link unit can never be required

And the platform refuses the combination outright. A link records nothing, so it can never complete — and a required unit that can never complete is a course nobody can finish.

Use links for supporting material: a policy to read, a video, a reference page. Leave them optional and put the assessed content in packages.

Sequencing: free or enforced

Free — the learner takes units in any order.
Enforced — units are taken in order, and a unit that gates the next holds it closed until completed.

Enforced for anything where order matters — an assessment that should follow the material, a briefing that must precede a practical. Free for a set of independent modules.

Completion rule

All required units — the course completes when every required unit is done.
A percentage — the course completes at a stated proportion, between one and a hundred.

The percentage rule suits a catalogue where a learner picks from several modules. For compliance, use all-required and mark the right things required.

Validity in months

How long a completion counts for. Zero means it never expires. Twelve means annual refresher, and the platform knows when somebody is due again.

This is what turns a training record into a compliance position.

Certificate template

A course can name a certificate template issued on completion. Worth setting where learners need evidence — and worth not setting where they do not, because certificates for trivial modules devalue the ones that matter.

Self-enrolment

Whether learners can enrol themselves. Right for a development catalogue; usually wrong for mandatory training, which should be assigned so the gaps are visible.

Draft, published, retired

A course starts as a draft. Publishing makes it available to learners; retiring takes it out of the catalogue without destroying the records. Learners see only published, enabled courses that have not been superseded.

Worked example

A compliance course has three units in enforced order — a briefing package, a policy link left optional, and an assessment package that is required and gates nothing after it. Completion requires all required units, validity is twelve months, and a certificate is issued.

Recommendations

Links optional, always — the platform will insist.
Enforced sequencing where order genuinely matters.
All-required completion for compliance.
Set validity months so refreshers are visible.

Versions and Refreshers

Courses change. Versioning is how they change without invalidating what people have already done.

Where to find it

Architect Panel → eLearning:

Courses & Assignments — the course console — courses, units, assignments
Learner Records — a learner’s registration against a package
Course Attempts — each attempt at a package
Course Sessions — individual launches
Learning Objectives — objective-level results

How versioning works

Creating a new version copies the course and its units, increments the version number, and stamps the previous row as superseded. The old version keeps its records; the new one starts as a draft.

So last year’s completions still refer to last year’s course, which is exactly what an auditor wants.

Learners only see the current one

The catalogue shows published, enabled courses that have not been superseded. A learner is never offered last year’s version, and does not have to know versions exist.

Version when the content changes materially

Not for a typo. A new version is a statement that what people did before is not the same as what they will do now — which matters if you are asked whether somebody was trained on the current policy.

Fix a typo in place; version when the material, the assessment or the standard changes.

Decide what happens to people mid-course

Before publishing. Somebody part way through the old version either continues on it or starts again — and starting again is a real cost to them. Have an answer before you publish rather than after somebody complains.

Validity drives refreshers

A course valid for twelve months means a completion expires twelve months later, and the learner is due again. That is what makes "who is currently compliant" a question with an answer.

Set it to the period your policy or regulator actually requires, not to a round number that feels right.

Cycles keep the history

Each refresher is a new cycle of the enrolment rather than a reset. A learner’s completed enrolment stays visible until the next cycle opens, so their course page shows their result rather than going blank the moment it expires.

And every cycle is retained, so you can show a learner’s history year by year.

Retire rather than delete

A retired course leaves the catalogue and keeps its records. Deleting a course with completions against it destroys evidence you may be required to hold.

Plan the refresher wave

If everybody was assigned at once, everybody expires at once. That is a large wave of training in one month, every year. Consider staggering the initial assignment so the recurring load is even.

Worked example

An organisation versions its security course annually when the content is updated, publishes in January, and allows anyone mid-course thirty days to finish the old version. Validity is twelve months and the original assignment was staggered across a quarter, so refreshers spread rather than arriving all at once.

Recommendations

Version for material change, edit for typos.
Decide the mid-course rule before publishing.
Retire, never delete, a course with completions.
Stagger initial assignment so refreshers do not bunch.