You’ve found a typo on slide 12, a policy has changed, or a quiz question has the wrong answer marked as correct. The course is live and some learners are halfway through it. Replacing the SCORM zip feels like a two-minute job, but done carelessly it can send people back to the start, drop them on the wrong screen, or leave their results out of step with what they did. Here’s how to update a SCORM course safely, judge the size of a change, and decide what happens to the people already in it.
Why updating a live SCORM course is risky
A SCORM package is a bundle of web content that runs in the learner’s browser and talks to the LMS through a small JavaScript API. As the learner works, the package sends data to the LMS, which stores it against that learner’s attempt. The main pieces are:
- Completion and success status: whether they’ve finished, and whether they passed.
- Score: usually from a quiz inside the package.
- Location: a bookmark to where they were (
cmi.core.lesson_locationin SCORM 1.2,cmi.locationin SCORM 2004). - Suspend data: a block of text the course writes for itself (
cmi.suspend_data) so it can restore its state, such as which slides were visited, variable values and answers given so far.
The important part is that the LMS doesn’t interpret suspend data. It stores it and hands it back unchanged when the learner resumes. The format belongs to the authoring tool, and it’s often tied to the structure of the course as published: the order of slides, the names of variables, the questions in a bank. For how the two editions differ, see SCORM 1.2 vs SCORM 2004.
What can go wrong when the structure changes
If saved data from the old package is handed to a new package with a different structure, the new course tries to restore a state that no longer exists. What happens depends on the authoring tool, but common symptoms include:
- The bookmark points to a moved or deleted slide, so the learner lands in the wrong place or back at the start.
- Menus and progress indicators show the wrong sections as visited.
- Answers saved against old questions are applied to new ones, or thrown away.
- The course ignores the saved state and starts over, or doesn’t load properly.
- A score earned on the old quiz sits beside a completion on the new one.
Switching SCORM edition, from SCORM 1.2 to SCORM 2004 for example, changes the data model itself, so saved data won’t carry across cleanly.
Not every change carries the same risk
Before you upload anything, work out what kind of change you’re making. What matters is how much the structure and the meaning change, not how long the edit took.
| Type of change | Examples | Risk to people part-way through | Usual approach |
|---|---|---|---|
| Cosmetic fix | Typo, wrong colour, a replaced image | Low: the structure is unchanged | Let them finish; new starters get the fix |
| Content refresh | Rewritten paragraph, updated video, a new slide at the end | Medium: depends on whether slides were added, removed or reordered | Usually let them finish |
| Restructure | Sections reordered or split, new branching, a new menu | High: saved progress may not match | Restart, unless people can finish on the old package |
| New or changed assessment | New questions, a different pass mark, a new question bank | High: results aren’t comparable | Restart |
| Corrective change | Old content is wrong, unsafe or non-compliant | High, whatever the structure | Restart, and decide about people who already finished |
A useful test: would you be comfortable if someone completed the old version today? If not, it needs to stop.
Let them finish, or make them restart?
When your platform can keep the old package running for the people who started it, you have a real choice. Work through these questions in order.
- Is the old version still correct? If it teaches something wrong or unsafe, restart people, however far through they are.
- Did the assessment change? If everyone should be assessed the same way, restart.
- Can the old package stay in place for existing learners? If your platform overwrites the files, “let them finish” really means “feed old progress into a new package”. Beyond a cosmetic fix, restarting is safer.
- How long is the course? Restarting a ten-minute module costs little. Restarting a two-hour course costs goodwill.
- Are deadlines close? A restart just before a due date can push people past it. Extend the deadline, or update in a quieter period.
The short version: if the old version is still right, let people finish it. If it’s wrong, restart them, and tell them why.
People who have already completed the course are a separate decision. A cosmetic fix or a content refresh rarely justifies asking them to redo anything. A corrective change might, especially for compliance training. If so, treat it as a new round of training with its own deadline rather than quietly changing anyone’s records.
Tell people what’s changing
A restart nobody explained feels like a bug. A short message beforehand turns it into a routine update.
- Learners who are restarting: what changed, why they need to start the module again, roughly how long it takes, and whether their deadline has moved.
- Learners who already finished: whether they need to do anything. If they don’t, say so.
- Managers and instructors: when the update goes live, and what to tell people who ask.
Keep a simple change log for each course, too: version number, date, what changed, who approved it, and what you chose for people part-way through. A version number on the final slide makes support questions far easier to answer. If you’re audited, the log explains why two people saw slightly different content; see what auditors want to see from your training records.
Before you upload: a checklist
- Keep the same SCORM edition unless you mean to change it.
- Check the publish settings match the previous version, especially how completion and scores are reported.
- Test the new package on its own first. How to test a SCORM package walks through it.
- Keep the previous zip and the source project, in case you need to go back.
- Decide in advance what happens to people part-way through, and draft your message.
How Acadenix handles SCORM updates
In Acadenix, every SCORM package is a unit in the Units Library, and one unit can be used in several courses. Selecting a unit shows the Courses using it, its Versions and its Users, so you can see where an update will land.
- A new file makes a new version. So do new text or a new unit type. Changing the name or description doesn’t.
- You choose for people part-way through. If anyone is in progress, you pick Restart them on the new version or Let them finish the version they started. People who start later get the new version.
- Finished learners keep their results. Completions are final and issued certificates never change. People who finished see the unit marked Updated, so they can look at the new version if they wish, and nothing they do then changes their result.
- You can roll back. Activate, on the unit’s Versions, brings back an earlier version.
- Retakes are a new enrolment. If people who finished do need to redo the course, the course’s Re-enrolment while a completion is valid setting lets them enrol again with fresh progress. Their earlier completion and certificate stay on record.
To check a package before it replaces the live one, upload it as a separate unit and use Preview, which shows it as a learner sees it without recording anything. There’s more on versioning and tracking on our SCORM LMS page.
Key takeaways
- SCORM progress is saved against the package a learner started, and suspend data only makes sense to the course that wrote it.
- Size the change first: cosmetic fixes are low risk, while restructures and new assessments aren’t.
- If the old version is still correct, let people finish it. If it’s wrong, restart them.
- Tell learners and managers what’s happening, and keep a change log for every course.
- In Acadenix, each upload is a new version, you decide what happens to people part-way through, and completions stay final.
Want to see how an update behaves with your own content? Request an evaluation and try uploading a new version of a real course.
