Migrate from other tools

You can move training into Coassemble whether it lives in an LMS, another authoring tool, or older legacy files. You rebuild the content in Coassemble (often quickly with AI from your source files, or automated through the API), and the move is a chance to modernise it.

Moving to Coassemble isn't a one-to-one file import. Other tools store courses in their own proprietary formats, so the reliable approach is to rebuild your content in Coassemble, using AI to do the heavy lifting from your original source material. For larger libraries, you can automate that rebuild through the API. Either way, migration becomes a chance to improve and modernise your training rather than copy it across as-is.

Leaving another authoring tool

If your training is built in another authoring tool:

1. Export or gather the source material you have (slide decks, documents, scripts, media).
2. Use Coassemble's AI to rebuild each course from those sources: transform a document or presentation, or generate from a prompt, then refine.
3. Recreate interactions using the closest Coassemble screen types, treating it as a redesign rather than a like-for-like port.

If all you have is the published output (and not the source), rebuild from the content itself. AI generation from a prompt or an exported transcript is usually faster than recreating screen by screen.

Moving from an LMS to Coassemble Embed and your own platform

If you currently author and deliver in an LMS but want training to live inside your own product:

1. Bring the content into Coassemble by rebuilding it as courses.
2. Deliver through Embed instead of the LMS: use Coassemble's embeddable components and API to surface courses, collections, and analytics natively inside your product.
3. Send results where you need them: tracking data and course events are available through the API and webhooks, so completions can flow into your own systems rather than staying in the LMS.
4. Transition gradually: during a changeover you can still export courses as SCORM to run in the existing LMS, so nothing goes dark while you move delivery across.

Moving legacy training in

For older training (legacy SCORM packages, slide decks, PDFs, or documents):

1. Find the original source files wherever you can. A well-structured document or deck gives AI the best starting point.
2. Use transform a document, convert a presentation, or generate from a prompt to rebuild each piece as an interactive, mobile-responsive course.
3. Use the move to clean up: refresh out-of-date content, drop anything no longer needed, and standardise the look with a theme.

Automate migration at scale with the API

For a large catalogue, you don't have to rebuild course by course in the editor. If you build with the Coassemble API, you can turn migration into a repeatable pipeline:

• Generate programmatically: use the Generate API to create courses, screens, and quizzes directly from your source content (prompts, documents, or presentations), at volume.
• Assemble and organise in bulk: use the content APIs to create courses and screens and group them into collections, so an entire library can be structured by script rather than by hand.
• Cut over cleanly: pull tracking and usage data back through the API as you retire the old system.

This is the difference between migrating ten courses manually and moving a few hundred in a controlled, automated run.

What carries over well

• Text content: headings, paragraphs, and lists move across directly.
• Images and video: standard media can be re-uploaded, and YouTube or Vimeo links copy across cleanly.
• Common quiz questions: multiple choice, true/false, and short answer map neatly to Coassemble's quiz types.
• Course structure: your module and lesson organisation can be recreated, even if the individual screen types differ.

What needs rebuilding

• Complex interactions (for example Articulate Storyline branching, triggers, and animations) don't have direct equivalents and are reimagined using Coassemble's screen types.
• Proprietary card or template layouts (for example 7taps cards or heavily templated designs) are redistributed across Coassemble's more flexible screens rather than copied.

A migration approach that works

For anything beyond a course or two:

1. Audit first. List your existing courses, rank them by use and importance, and don't migrate low-value or unused content.
2. Plan to redesign, not copy. A direct port is rarely possible, and "better but different" is the goal.
3. Start with one course. Migrate it end to end to validate the process, set a visual style, and estimate effort.
4. Use AI to accelerate. Rebuild from original sources with AI generation, or automate with the API for larger libraries.
5. Phase the rollout. Move high-priority courses first, retire the rest, and build in review time for each rebuilt course.

Frequently asked questions

Can I import my existing course files directly?

Not as proprietary files. You rebuild courses in Coassemble, using AI to generate from your original documents, decks, or prompts, and you can automate this at scale through the API.

Can I automate a large migration?

Yes. With the Coassemble API you can generate and assemble courses programmatically, so a big catalogue can be rebuilt as a scripted pipeline rather than course by course.

Can I keep using my LMS during the move?

Yes. You can export courses as SCORM to run in your existing LMS while you transition delivery into your own product with Embed.