AI-assisted storyboard-to-Canvas workflow
A three-stage evolution of how storyboards become Canvas content — from a page-by-page custom GPT to a Claude project handling full storyboard sections, to a Make integration that transfers the output into pre-created Canvas pages. What changed isn't only the speed. It's where time gets spent.
Project overview
A workflow I built to turn instructional storyboards into Canvas-ready content without the manual copy-paste pass.
It evolved over three stages: a custom GPT for snippet conversion during the early uplift work on the King's College London programmes, a Claude Project that handles full storyboard sections (with slugs, glossary hyperlinks, and banner variations), and a Make integration that transfers the converted content into pre-created Canvas pages by matching slugs.
The most useful outcome isn't speed. It's that QA happens with fresh eyes — after the build, not during it.
Key features & outcomes
- Developed a three-stage workflow, evolving from page-by-page snippet conversion to an integrated Claude + Make process
- Converted full storyboard sections in a single Claude Project, including page slugs, glossary hyperlinks, banner variations, and consistent page structure
- Built a slug-matched Make integration that transfers converted HTML into pre-created Canvas LMS pages
- Reduced repetitive copy-paste production work and shifted time toward QA before course content goes live
- Designed the workflow for ongoing uplift work on the King's College London programmes
After the original Canvas build wrapped in early 2024, the work shifted to ongoing uplifts — updating modules, refreshing content, applying improvements identified during live cohorts. Each uplift cycle involved the same pattern: take a storyboard, convert structural tags into Canvas-ready HTML, paste page by page into Canvas, format, repeat.
The custom GPT I built solved part of this. It recognised tags like accordion or resources and returned the matching HTML snippet. That saved typing but didn't change the shape of the work — still page-by-page, still followed by manual paste.
The bigger issue was downstream. Even with the GPT, once a storyboard was converted, every page still needed to be created in Canvas and pasted in by hand. By the time the content was live in Canvas, I'd been looking at it for so long that "fresh-eyes QA" wasn't fresh any more.
What I needed wasn't a faster snippet converter. It was a workflow that took a whole storyboard section in, and produced Canvas-ready content out — leaving me to do QA on something I hadn't already touched ten times.
Each stage took a few weeks to build once the right tools were available. The two-year arc is the gap between stages, not the build time.
Stage 1 — Custom GPT for snippet conversion (early 2024). Built during the early uplift phase on the KCL programmes, after the active build had wrapped. The GPT recognised structural tags in storyboards and returned the matching HTML snippet. It saved typing but didn't change the shape of the work — still page-by-page, still followed by manual paste.
Stage 2 — Claude Project for section-level conversion (mid-2025). Migrated the conversion to a Claude Project — Claude handled code output more reliably than ChatGPT for this kind of structured HTML work, and Projects let me load the storyboard format and conversion rules into a persistent workspace. Instead of one page at a time, the Project handles full storyboard sections: HTML for every page, a page slug for each page (the critical output), glossary hyperlinks woven into the prose, banner variants for different page types, and consistent structure across every page.
The slug generation sounds dull and it's the most important output. Get the slug right and the next stage can run unattended. Get it wrong and nothing matches.
Stage 3 — Make integration with Canvas (March 2025). A Make scenario bridges Google Workspace and Canvas LMS: it picks up the Claude-converted storyboard from Drive, parses it into individual pages, matches each page to the pre-created empty Canvas page by slug, and transfers the HTML into the right slot. The pre-created empty Canvas pages step matters — I still set up the structure in Canvas first. The automation only handles the content transfer, not the structure.
A storyboard section that previously took a day of paste-and-format work now goes from Drive into Canvas in under a minute.
Where to put the AI. Putting it at the front of the pipeline — convert the storyboard, then automate the transfer — was much more effective than scattering AI across multiple steps. One concentrated AI step, one reliable automation step, clear handoff between them.
What not to automate. The pre-created Canvas page structure is intentionally a human decision — module ordering, page types, learning flow. Putting that under AI would have made the workflow brittle and harder to QA.
The QA point. I built this for speed and what I got back was attention. By the time content lands in Canvas now, I haven't been staring at it for hours. The QA pass catches things the previous workflow missed simply because I'm not exhausted by the production phase.
Workflow tools age fast. The 2024 custom GPT was useful at the time and ordinary a year later. The transferable skill isn't the specific tools — it's noticing where the manual work is and being willing to rebuild when the tools catch up.