Appearance
Structuring a Course
Courses are your building blocks — one per session, per week, or per program, whichever fits. This guide covers how to shape them so credit, completion, and reporting all fall into place.
"Lecture" and "course" mean the same thing
LecturePanda uses both words for the same container. Each one holds its own learning materials, quizzes, credits, and registration — which is why "split it into separate lectures" is the answer to so many structural questions.
What a single course holds
A course is the container for everything a learner works through and everything they earn. Each piece below belongs to one course and applies across all of it:
| What | Covers |
|---|---|
| Learning materials | Videos, downloadable files, on-screen text sections, and xAPI/SCORM modules — everything the learner moves through |
| Quizzes and evaluations | Knowledge checks, graded post-tests, and surveys, each aimed at everyone or at particular credits and registration types |
| Credits | What can be earned, which registration types earn it, the hours it carries, and the certificate it produces |
| Speakers | Your presenters and their access to the audience response portal |
| Registration | One sign-up covering all of the above, with its own registration types, pricing rules, and registration security |
| Completion rules | What has to be finished, and in what order, before a learner can claim |
That makes the course your scoping tool. Anything on that list applies to the whole course, so when a piece of content needs rules of its own — this handout for this lesson only, this module required while the rest are optional, this exam for one audience — give it its own course.
Courses are quick to create and can be chained with prerequisites, so splitting is the normal way to get precise control, and it costs you nothing in learner experience. Most of the structural questions further down this page resolve to the same move.
Scoping one file to one lesson without splitting the course
Storyline lets you attach downloadable files inside the module itself, through its Resources panel. The file then travels with that lesson and your course structure stays exactly as it is.
Where each of these is configured
Each row above is a tab on the course: Materials, Quizzes, Credits, Speakers, Payments, and Registration Security. The Details tab carries the course's own name, dates, and registration types.
Long-running programs: a course per session
When content rolls out over weeks or months, give each session its own course and its own registration. Each session then completes, certificates, and reports on its own schedule instead of waiting on the last piece of the program.
The learner feels the difference first. Under one umbrella registration, people naturally hold off claiming until they've finished everything — so a program running January to June produces no completion records until June. A course per session means each one is claimed while it's fresh, and your reports show real progress through the program as it happens.
Bundling into one course with multiple credits is right when:
- All sessions happen in one event or timeframe, such as a multi-day conference
- Everything will be completed and claimed within the same short window
Split into separate courses when:
- Content rolls out over more than a couple of months
- Learners work at their own pace across months
- Different learners complete different subsets of sessions
- It's a series: a multi-part certification, longitudinal training, ongoing in-service CE
If you report to an accreditor
Submission deadlines can make this decision for you. ACPE's window, for example, runs per credit — timed from that credit's own activity date rather than from when the learner finishes the program — so sessions bundled under a single registration can age past their individual windows while the learner is still working through the material. Check your accreditor's timing before bundling a long program; see ACPE Credits if that's the one you report to.
Multi-week pathways
For a guided program — a welcome video, a reading, a podcast, a checklist, and a knowledge check each week, over several weeks — build one course per week and chain them with prerequisites so week two opens when week one is complete.
That gives you per-week learning materials, per-week completion tracking, and gating between weeks. A typical week maps onto LecturePanda like this:
| The step you have in mind | How it's built |
|---|---|
| Watch | An embedded video (Vimeo or YouTube hosted) |
| Read | On-screen lesson content rather than a PDF |
| Listen | Embedded audio |
| Download | A file in that week's learning materials |
| Knowledge check | A quiz with a passing grade and attempt limit |
| Reflect | A short response step, or built into an xAPI module |
Two things to plan around:
- When a week has to run in a strict sequence, author it as a single xAPI module in Articulate Rise, Storyline, Captivate, or iSpring and upload that. You get exact control over the order and flow within the week, and Rise in particular suits the guided-pathway feel. For weeks where order doesn't matter, the standard materials layout is quicker to build.
- Automatic reminders cover your first 60 days. Learners who haven't finished are nudged weekly, starting the day after they register, and the nudges stop as soon as they complete. For a pathway that runs longer, Zapier can carry the reminders through to the end.
Reminders respond to progress
Built-in reminders follow each learner's own progress, so someone who's already finished never gets chased. When you want calendar-driven messages instead — "it's Monday of week 3, here's your next module" — Zapier's completion and registration triggers give you that, and the two work well together.
Live and on-demand: one course each
After a live conference, the fastest way to publish the recordings is to duplicate the course and run the on-demand version as its own. You keep the live course as a clean record of who attended, and the copy is ready for on-demand learners in a couple of clicks.
A live course is built around a live event, and each of its settings is tuned for that:
- Access codes verify live attendance, which is exactly what you want for the live session — and the on-demand version verifies a different way.
- Video tracking is typically off for live courses and on for on-demand, where watching the recording is the thing being verified.
- Live event reminders are timed to the event date, which is right for attendees and irrelevant to on-demand learners.
- Reporting stays clean when each course serves one cohort with one set of requirements.
The clean pattern: leave the live course intact as the record for live attendees, duplicate it for on-demand, swap the code requirement on the duplicate's credits for the video tracking requirement, and let each course do its job.
A learner who takes both uses two registrations, and so two participants from your bank — worth knowing when you size it, and a small price for two sets of records that stay straightforward to report on.
Two audiences with different exams
When two groups share a course but sit different final exams — supervisors and staff, nurses and aides, pharmacists and technicians — give each group its own credit. Duplicate the credit, attach only the first group's exam to their credit and only the second group's exam to theirs, then set the registration types on each. Each learner sees exactly the exam that applies to them, and each group can carry its own credit hours and its own certificate.
Since a credit requires every quiz attached to it, keeping the two exams on separate credits is what makes that clean separation work. See Claiming Credit if a course already has both on one credit.
When both groups answer identical questions, a single shared quiz is the simpler build — filter the results by registration type afterwards.