A Course Builder

The tool I’ve been imagining for a while now is something bespoke for the development of courses. Something that would combine the features of previous work that I’ve done around single source publishing, pattern languages, metadata and the difference between authoring and presenting content.

I’ve been asking myself a number of questions:

• Rather than the cobbled together solution that we’ve been using of folders, documents and spreadsheets that are often unreliable – what if we could just streamline the process?
• What if we could add value to the writing experience by making it a simpler, supported and where possible automate many of the manual tasks and communication that is required when working on static documents?
• What if we could embed sound pedagogy into the development process for content and write explicitly to that design rather than require staff time to review and fix retrospectively?
• What if we could automate more of the build process and allow us to review the course as it would look and function before it goes into platform and reduce that last minute rush?
• What if we could use basic digital tools like search, find and replace, and data sources to reduce repetition and tiresome manual updates to key information throughout a course?
• What if we weren’t constrained by tools that we’re fit for purpose? What if we could ditch Word, Excel and the LMS and just focus on just creating the course itself?

Well I’ve been slowly working through each of those questions and now I think I have an answer – a Course Builder. The aim now is to get a proof of concept up and running with my team over the next few months.

What does it do?

The design process we have been developing will allow a learning designer and subject matter expert to co-design and develop a course from start to finish. A lot of the initial design work will sit in Miro, which currently has the tools we need to collaborate and sketch out the design of the course together. The Course Builder comes right at the end of the co-design phase, after the assessments have been developed and the course has been mapped out into “lessons”. Within our team we have implemented a tweak to our design process where a lesson is an addressable question rather than a topic. This provides focus for both the students in their learning as well as the course author when it comes time to write, by setting clear bounds on what they will be covering.

The Builder will work with any duration of course and nomenclature but is based on a basic hierarchy that looks like:

1. Course
2. Duration
3. Lesson
4. Block
5. Element

For our use the duration is set to weeks – as we’re working with 12-week courses, but it could quite easily be adapted to any length, even days. Duration allows us to group lessons together essentially and build out defined sequences of lessons.

Once the scaffold of the course has been setup the main area of work is within Lessons. Each Lesson is constructed using Blocks – these are components for content and activities for students to complete. For the main part this is where our Learning Activities and Patterns come into play as each Block is setup with its own metadata that records – what pattern is being used, who is responsible for it, and the current status. It’s from this information that we are able to generate reports that cover the state of the course in development and what the student experience is going to be like. We can track students time-on-task and visually spot any issues or missing elements within the design of the course quite quickly. If you’ve used a site builder in any content management system, WordPress comes immediately to mind, you’ll’ be familiar with the interface style we are going for.

This mockup of the Designer view would allow the designer and course author to build out the course quite quickly and add in any meta data:

Moving from the course map to Lessons also ensures that we have a complete course designed from the outset of the process. There is a fair amount of pre-work that has come before we get to the Builder stage. At the beginning this may just be a very rough skeleton of dot points, but this will grow and become higher fidelity as the work gets completed. The patterns used for each block don’t just specify the type of learning, they also provide specific scaffolding text and explanations to help the author develop the content required for that section or to build out the activity. In this way it is like having a 24/7 learning designer on hand to help guide the development throughout the course – an in built guide on the side. This mockup of the Writer view shows how the Block would switch to a rich text editor and display the scaffolding text to the right side of the Block.

The final element to this is the ability to get a styled preview of the course. Seeing as we’ll be writing in clean markup and not inside a word processor document, this will allow us to generate a live Preview of each Lesson. Depending on the text editor, this could work with our design system and allow us to include specific styled elements we have developed for our courses such as Stepped Lists, Cue Boxes, Buttons etc.

The plan is to get this essential functionality developed and then look at additions moving forward. Adding new views and Reports (essentially course level queries on Lesson data) can be done on the fly without impact on course development so we have time to develop more of those.

This is definitely just the first step in developing this tool, but I am excited by it!. It improves on a huge number of areas where we have encountered issues and bottlenecks in the past, so anything that can help to alleviate that is going to make like better. I am hoping we can get this up and start to build some momentum to keep development rolling.

Advertisement