Types of storyboards for online courses
At its core, every storyboard has to present the "story" of each screen. Every time a user loads a new page, that screen needs to be in the storyboard. The different types of storyboards simply show more and more elements within each of those stories, going from the simplest to the most complex. There are four basic types of storyboards for online courses: low fidelity, mid fidelity, high fidelity and prototypes. It's worth stressing that there is no single way to build a storyboard. Every company will have its own standard. I'll show you how I do it, but yours will certainly look different for University X, instructional design agency Y or school Z. Let's go through each type of storyboard, shall we? Below, you can browse the types and see a real example you can put to use right away, okay?
Low-fidelity storyboard
The low-fidelity storyboard is the simplest model, or in technical terms, the one with the lowest fidelity. Why low fidelity? Because it doesn't show what each screen will look like visually, with all its resources. It only describes it. It contains just a written description of what will happen on each screen, which media will be used and, of course, whether there will be any interactive element. At this stage you don't design where each element will sit. That's why it's very common to build these storyboards in a plain Word document. It's ideal for quick situations, when the team already works well together or when the content is simple but still needs planning. For example, I'm working on this storyboard course completely solo. With no one else involved and a simple course, I'll use a low-fidelity storyboard just to plan the content I have to produce.
Mid-fidelity storyboard
A mid-fidelity storyboard defines elements through blocks. They work as a spatial representation of where each element fits and how it will be presented. As in the example here, you'll see several "codes" and markers. It's extremely important that these conventions, such as how to use each box or color, are agreed on or spelled out in the template itself. Of course, you can choose a simplified version to get started with your team or even to present to your client. But trust me, you'll want those codes because they make everything much easier and they save space on screen. I believe a mid-fidelity storyboard is the perfect balance between the time spent building it and the benefits it brings. A low-fidelity storyboard, for instance, isn't visual at all. A high-fidelity one involves choosing images to compose the scene and already contains more detailed planning of what each quiz will include, for example. Finally, the prototype is the representation of what the environment will look like for the learner, so it's the stage closest to the final version.
High-fidelity storyboard
Now for the most complex one: the high-fidelity storyboard. The big difference between this one and mid fidelity is that it describes more elements. Here, the team is probably larger. In the example I'm showing, you can already see the images that will be handed over to the animation and development teams. The work is divided among more people. As an instructional designer, I have to plan the course, but I don't necessarily deliver everything. Here, conventions and codes are almost mandatory to save time and speed up the process. The main goal of this type of storyboard is that every person responsible for creating the educational content can look at it and know what their tasks and responsibilities are, without having to step in or ask extra questions. Of course, it's perfectly normal for those questions to come up. Still, your job when building one is to save your team as much time as possible.
Prototype
Finally, we get to the prototype. By definition, a prototype is a preliminary model of a project. It can come in two forms: either you have a navigable, interactive page or you have a staging environment. A navigable prototype lets you click through the course pages in a prototyping tool such as Figma. A staging environment, in plain language, is a test site. It's an address, for example test.yourdomain.com, where I can put any content with reasonable confidence that no one will see it or, if a bug happens, that it won't affect navigation. This is very common in software development, for instance, when you don't want users who are on your site right now to see what you're planning to release or to run into unfinished features. Applied to instructional design, you can create a staging environment, a testing environment, a replica of your platform where you can upload your course and content. That way, if you make a mistake, it won't affect your users. It's common to build courses in a closed environment first and launch them afterward. This is the closest version to the final one, since the goal of a staging version is to be identical to the final version. When it's ready, we flip a switch and it goes live in the production environment, where users have access. Of course, if you already have an LMS set up and configured, you can start placing elements into a draft course and show how it's shaping up, testing for possible failures or even validating the learner's experience flow. Keep in mind that the prototype is not part of the planning: it's already execution. So if your project calls for a prototype, you'll probably combine it with one or more storyboards. Right? Or when you have a client with more than one decision maker. Sometimes there's the person who approves and the person who is investing in the project, who is usually your point of contact's boss.
