How to design microlearning courses in Slate

You built a polished course. Your learners took it once. A month later, most of what you taught is gone. That is not a failure of your design. It is what the research has been telling us since 1885: without reinforcement, people forget most of what they learn, and they forget it fast. We cover the full science in our microlearning guide, but the short version is that a single long course is almost never enough on its own.

The good news is that you do not need to rebuild anything from scratch. The courses you have already written are the raw material for a whole series of shorter, focused units you can deploy after training, between classroom sessions, or at the moment a learner needs them on the job. This post is a practical playbook for creators who want to turn one large course into several smaller ones in Slate.

Why one big course is rarely enough

Long-form eLearning and instructor-led training do real work. They are the right shape for first exposure, for framing, and for the kind of deep dive that builds a mental model. But the moment the session ends, the forgetting curve starts. If you want the learning to stick, you need to re-expose learners to the material in short, spaced bursts.

That is what microlearning is for: short, focused units, each built around a single learning objective, delivered as a series over days or weeks. It is reinforcement, not replacement. Your primary course does the heavy lifting. Your micro-units keep the learning alive.

Start by duplicating what you already have

The simplest way to build your first micro-unit is to duplicate an existing course and reduce it. In your Slate dashboard, find a course you have already published. Open the course menu and choose Duplicate. Open the copy, pick one lesson that covers one idea, and delete everything else.

Rename the new course to match the objective, not the topic. "Responding to a phishing email" is a microlearning objective. "Cybersecurity" is a topic, not a unit. If you need the word and to describe what the course covers, split it again.

Once you have one unit, you have a template. Duplicate that, swap out the content, and you have the next unit in the series. What would take hours to build from scratch takes minutes when you start from something that already works.

Five ways to chop a large course into smaller ones

1. By lesson. If your main course has ten lessons, each of them is a candidate for a standalone micro-unit. Lift the lesson, add a short hook at the start and a retrieval moment at the end, and it stands on its own.
2. By objective. Look at the course outline and list every distinct learning objective. Each objective is its own unit. Most creators are surprised by how many "hidden" objectives are buried inside a single lesson.
3. By audience. A sales onboarding course probably covers product pitching, objection handling, pricing questions, and follow-ups. Each of those is a different conversation for a different moment. Split them.
4. By context. A safety course that has to work in a classroom, on a tablet in the field, and on a phone between shifts is really three different experiences wearing the same content. Build one longer course for classroom delivery and shorter micro-units for the field and phone.
5. By skill tier. A "getting started" unit, an "intermediate" unit, and an "advanced" unit each serve learners at different stages. Instead of one course trying to cover everyone, build three short courses that each cover one tier well.

Where microlearning fits around your primary training

The highest-leverage use of microlearning is not as a standalone experience. It is as the connective tissue around a larger training event. Six patterns that work:

• Post-class reinforcement. After a live classroom or webinar session, drip one short unit per week for a month. Each unit revisits one key idea from the session with a fresh example and a retrieval question.
• Post-course follow-up. After learners finish your main eLearning course, send a short unit at day three, day seven, and day fourteen. Space the intervals to roughly match how long you need the content to stick. Our microlearning guide has more on the spacing research.
• Pre-training priming. A two-minute unit before a live session that frames the problem and gets learners thinking about the topic. Preparation for the real thing.
• Just-in-time job aids. A one- to two-minute how-to unit a learner pulls up on their phone at the moment they need it. Not a training event. A reference.
• Compliance top-ups. Instead of one forty-minute annual compliance refresh, a three-minute unit per policy per quarter. Smaller changes land harder.
• Onboarding drip. Replace the day-one onboarding firehose with a series of three- to five-minute units delivered one per day across the first two weeks.

What good small courses look like

A few rules of thumb that come straight out of the learning research:

• One objective per course. If you cannot state the objective in a single sentence, split the course further.
• Three to seven minutes. Long enough for a hook, a concept, an example, and a retrieval moment. Short enough to fit between two other tasks.
• End with retrieval, not recap. A summary slide is not learning. A question that makes the learner pull the answer from memory is. Every micro-unit in Slate should end with a knowledge check.
• Space the series. Ten units released on the same day is not microlearning. It is a course in small pieces. Schedule the release across days or weeks.
• Design for mobile. Most reinforcement microlearning is consumed on a phone. Short paragraphs, clear visuals, no wide tables.

Building it efficiently in Slate

A few Slate features make this a lot faster than starting with a blank canvas:

• Course duplication. Duplicate any course from the dashboard and use it as the starting template for a micro-unit. Strip out anything that does not serve the single objective.
• AI lesson generation. Ask the AI to draft a short lesson from a prompt and you get a first pass on the page in seconds. Keep the scope tight and you end up with something close to a three- to five-minute unit, ready for you to refine.
• Knowledge check blocks. Add one at the end of every unit. Retrieval practice is the single highest-leverage part of a micro-unit, and it is a built-in block in Slate.
• Tagging. Tag every unit in a series with a shared tag (for example, onboarding-drip) so they are easy to find, organize, and export together.
• Share & Track. On Standard and Pro, create a trackable link per unit and send them out on the schedule you want. See which units are landing and which are not. Read more.
• LESSON.md or SCORM import. If you already have content in another tool or a Markdown draft, import it as a starting point rather than retyping from scratch.

A note on the Free tier

The Free tier includes five courses. That is a natural size for one primary course plus four short reinforcement units around it. If you have been using a single "mega-course" slot to carry an entire program, you are leaving learning outcomes on the table. Splitting the content into a series almost always works better for learners, and it uses your course library the way the research on retention suggests you should.

If you are building a larger program and run out of room, Standard and Pro raise or remove the course limit. But most creators find the five-course Free tier is plenty of room to experiment with the pattern and see whether it moves the needle in their program.

Where to go next

If you have not read it yet, the Slate microlearning guide covers the science behind all of this: the forgetting curve, spaced practice, working memory limits, cognitive load, and the testing effect. It also has an interactive fit checker that tells you whether a given topic is a good candidate for microlearning or whether it needs a longer form.

Then pick one course you have already built in Slate, duplicate it, and try cutting it down to one objective. That first unit is the hardest. After that, you have a template, and building the next one takes a fraction of the time.