L&D and training

What does Coassemble give someone responsible for training and content creation?

What this person gets from Coassemble: a way to build structured, trackable training whether you're starting from existing documents, moving off another authoring tool, or replacing an LMS, kept on brand and accessible along the way.

Coassemble builds structured, multi-screen courses from whatever you're starting with: documents, slide decks and manuals for teams coming from more traditional or informal training, existing courses for teams moving off a tool like Articulate, or training currently delivered through an LMS. It keeps courses on brand and accessible, and tracks whether people actually complete them, whichever of those is your starting point.

Whether you're the one championing this end to end or working alongside others who are already driving parts of it, getting Coassemble in place is rarely a one-person effort. Depending on how far the rollout goes, a handful of other teams typically get pulled in alongside whoever's leading it, some only briefly, some more closely. Knowing roughly who they are and when they show up tends to make the process feel a lot less overwhelming than it does at the start.

What other teams might I need to involve?

Depending on scope, a few other teams tend to get pulled in along the way, whether you're leading this or contributing to a rollout someone else is driving:

• Product team. If Coassemble is being embedded into your own product, product often owns the decision on where it sits in your roadmap and how it's positioned to your own users, separate from the technical team doing the actual build.
• Technical/development team. Needed specifically for embedding Coassemble inside your own product, not for building or managing course content.
• Marketing team. Since courses carry your own logos, colours, and tone of voice, it's worth having marketing review the Brand kit setup before a wider rollout, rather than after. This may be absolutely critical if you are using Embed for a customer education or publicly available learning experience.
• IT or security team, if your organisation runs a vendor review. Questions about accessibility and security are common at this stage.
• HR or People team, if this crosses into compliance or workforce-wide training. They may already own related budget, systems, or reporting requirements, so looping them in early avoids duplicating work or hitting a conflicting process later.

None of this needs to happen all at once, or in a fixed order. Which teams actually need to be involved depends entirely on your organisation's setup and how far this rollout is going, this list is just the common cast, not a mandatory checklist.

Getting your content into Coassemble

How do I turn training we already have into a course, instead of rebuilding it from scratch?

You have three starting points, depending on what you're working from:

• Transform a single document: upload a Word doc or PDF and AI structures it into a multi-screen course with headings, body copy and suggested knowledge checks.
• Combine multiple documents with a prompt: upload several files together with a guiding prompt, and AI merges the different sources into one cohesive course.
• Convert a presentation: import a PowerPoint or Google Slides deck and it becomes a course, keeping the structure, text and imagery.

This isn't a reformat of the file. AI is informed by learning design rather than just reflowing text into screens, and everything it produces is fully editable afterwards: accept what it builds, edit any part in the course editor, or rebuild specific screens by hand. If there's no source document at all, you can also generate a course from a prompt describing what you need, useful for a first draft to react to.

Should I upload our 60-page handbook as one course?

Generally, no. Documents are meant to be referenced. Courses are meant to guide someone through learning a step at a time, and a long document dropped in as a single course tends to overwhelm learners and hurt completion.

The better pattern is to split it before or during the transform:

1. Break the source document into smaller documents along its natural topic breaks (for example, a 100-page onboarding handbook becomes "Welcome & Company Culture," "Tools & Tech Setup," "Policies & Compliance," "Your First Week").
2. Transform each smaller document into its own course.
3. Group the resulting courses into a collection, a structure that links related courses into a single learning journey.

Collections have a practical upside beyond learner experience: you can improve one course in the collection without reworking the whole series, and you can track progress across the collection rather than one long course. This is the same logic that applies to a large slide deck: a 70-slide presenter deck built for someone standing in front of a room doesn't hold up as a single self-paced course, because slides carry meaning through a live presenter and interactivity has to be built in rather than assumed.

We already use another authoring tool. Does our existing content carry over?

Some of it, cleanly. Plain text, standard formatting, images, video (YouTube and Vimeo links generally copy across cleanly), and simple quiz questions (multiple choice, true/false, short answer) all map across with minimal rework.

What doesn't carry over cleanly is anything tool-specific: complex branching interactions or animated triggers built in tools like Articulate Storyline, proprietary fixed-card formats like 7taps, or heavy template-based layouts like Chameleon Creator. These need to be rebuilt using Coassemble's screen-based authoring rather than copied directly.

If you're migrating a meaningful library rather than one or two courses, the approach that avoids surprises is:

1. Audit first. List existing courses and rank them by actual usage. Don't migrate what nobody uses.
2. Plan to redesign, not copy. A one-to-one port is rarely possible or actually desirable. The goal is better, not identical.
3. Start with one course as a proof of concept before committing to the whole library.
4. Use AI course creation to accelerate the rebuild wherever you still have the original source files (PDFs, decks, documents).
5. Phase the rollout, moving high-priority courses first and using the migration as a chance to retire content nobody needs anymore.

Build in review time. Every rebuilt course still benefits from a stakeholder read-through before it goes live.

Working with your existing systems

We already use an LMS. Will Coassemble work alongside it?

Yes. Coassemble doesn't require you to replace an existing LMS, and there are two ways it fits alongside one, depending on how you want training delivered.

Export as SCORM and host it in your LMS. Export any course as a SCORM package (SCORM 1.2 or SCORM 2004) and upload it into your existing LMS, whether that's Moodle, Totara, or something else that accepts SCORM. You get two types:

• Dynamic SCORM keeps a live connection back to Coassemble. Edits you make in Coassemble update automatically for learners, no re-export needed.
• Standalone SCORM is a self-contained file that runs independently of Coassemble. Good for offline or high-security environments, but it's a static snapshot: to update it, you edit in Coassemble, export a new package, and replace the file in your LMS.

If your course has translations, the SCORM package respects them, learners get the version matching their environment the same way they would inside Coassemble directly.

Deliver it outside the LMS entirely. If you'd rather not route training through the LMS at all (for example, embedding a course library into an intranet, a customer portal, or your own product), Coassemble's embeddables and API deliver courses and analytics directly, independent of any LMS.

One honest trade-off worth knowing: once a course is running inside another LMS via SCORM, that LMS holds the detailed completion and scoring data, not Coassemble. From the Coassemble side, you still get SCORM usage insights, unique views, where the package is hosted, and usage over a date range, but the fine-grained pass/fail and progression detail lives in whichever system is actually hosting it.

Do we need to migrate away from our LMS to use Coassemble?

No. You can keep your LMS and use Coassemble as the authoring layer, exporting into it via SCORM, or run training separately through Coassemble's own delivery and analytics.

Where will completion data show up, our LMS or Coassemble?

Depends on the path. Export via SCORM and your LMS holds the detailed completion and scoring. Deliver directly through Coassemble (a share link or an embed) and Coassemble holds the detailed tracking instead.

Can we move away from our LMS entirely and deliver training through Embed instead?

Yes, and it doesn't need to happen as a single cutover. The path looks like this:

1. Bring your content into Coassemble by rebuilding it as courses, using AI to generate from your existing source material (documents, decks, scripts), or the API if you're moving a large library.
2. Deliver through Embed instead of the LMS. Use Coassemble's embeddable components and API to surface courses, collections and analytics natively inside your own product, rather than sending people to a separate LMS.
3. Send results where you need them. Completions and course events are available through the API and webhooks, so tracking data can flow into your own systems instead of staying locked inside the LMS.
4. Transition gradually. While you're moving delivery across, you can still export courses as SCORM to keep running in your existing LMS if needed, so training doesn't go dark mid-transition.

Do we lose training delivery while we make the switch?

No. You can export courses as SCORM to keep them running in your existing LMS while you build out delivery through Embed, so the changeover can happen gradually rather than as a single cutover.

What happens to our tracking data during the move?

Completions and course events are available through the API and webhooks, so you can start routing results into your own systems as you migrate, rather than losing that data or leaving it stuck in the old LMS. Your development team should be involved in the plans around tracking from day 1.

Keeping it on brand, accessible, and collaborative

How do I keep new courses on brand?

The Brand kit is the single place that manages this: logos (with support for multiple variants like Primary, Secondary, and Icon, in SVG, PNG, or JPG), themes (colours, fonts including custom font uploads, and logo placement, saved and reusable across any course), and brand voice.

Brand voice settings control the tone, personality and writing style of anything AI writes, so course content doesn't come out reading like generic AI output. Whatever AI produces stays fully editable, so a subject matter expert can review and adjust the language before anything publishes.

What happens to our images and video at scale?

They live in the Asset library, inside the Brand kit. Anything uploaded to a course, or pulled in from stock photography or GIPHY, is added automatically, and you can also upload files directly. Each asset can be tagged for searchability and given default alt text, so you set the accessibility description once rather than re-adding it every time the image is reused. Supported formats are JPEG, GIF, PNG, and SVG.

How do multiple people create and manage content together?

Coassemble doesn't limit how many people can create content in your workspace, so subject matter experts, writers and other contributors can all work in the same place. Anyone invited as a creator can create, edit, and share any course in the workspace, and see all course insights. What creators can't do is invite other creators, change your plan or billing, configure allowlists, or access your workspace API key, those stay with the workspace owner.

Folders keep things organised as more people contribute, letting you group courses (by subject matter or team, for example) so people can find what they need. Worth knowing: folders are for your own organisation, not an access restriction. Every creator can still access every course in the workspace regardless of which folder it's in. If a creator leaves, their content stays in the workspace, only their own access is removed.

For quality control across multiple contributors, the practical pattern is a standard review step, a subject matter expert or lead reviewer checking new content before it goes live, applied consistently regardless of who built it.

If we remove someone as a creator, do we lose their work?

No. Their content stays in the workspace under your account. Only their access to log in and edit is removed.

Can we restrict a creator to only certain courses or folders?

Not at a permissions level. Every creator can create, edit and share any course in the workspace. Folders help you organise content, but they don't restrict access.

Does Coassemble handle accessibility for us?

Coassemble has been independently verified as conforming to WCAG 2.2 Level AA for the learner experience, but accessibility is a shared responsibility between the platform and how your team builds courses. The practices that matter most for a content team:

• Alt text on images. Under 125 characters, describing the purpose of the image (not just "a chart," but "bar chart showing sales growth over three years"), left blank for purely decorative images.
• Contrast. Default themes are built with sufficient contrast; if you override colours manually, check them against WCAG guidance.
• Screen type choice. Standard screens work well with screen readers. Hotspot screens (interactive labels on images) need care, since assistive technology doesn't always interpret them clearly; if a hotspot carries critical information, repeat it in text elsewhere.
• Captions on video. Coassemble doesn't generate or manage captions for directly uploaded video. If you're embedding from YouTube or Vimeo, caption it on the source platform first.
• No essential text trapped in images. Screenshots of slides or text-heavy graphics aren't readable by screen readers, so keep meaningful text in the course content itself.

Can learners take the same course in different languages?

Yes. A translation is a "child" of your original course: it keeps the same structure, but you localise the text and images per language, and can generate AI narration so learners hear it as well as read it. Translations load automatically based on the learner's browser language, so nobody has to pick one manually, and it falls back to your default language if theirs isn't supported. Coassemble supports course translation into more than 40 languages, including regional variants like French (Canada) and Spanish (Spain, Mexico, Latin America).

Proving it's working

How do I know whether people are actually completing the training, not just opening it?

Quizzes are a screen type that check understanding, either sprinkled through a course or as a final assessment. They auto-grade and support seven question types:

Question type	What the learner does
Multiple choice	Selects one answer from a list
Multiple response	Ticks all correct answers
True / False	Decides if a statement is true or false
Short answer	Types an exact word or number
Fill in the blank	Completes a sentence using dropdown menus
Match corresponding	Pairs items by selecting their counterpart
Match sequence	Puts items in the correct order

A quiz can be unscored (practice, unlimited attempts, no formal grade) or scored (a passing grade, a set number of reattempts, and it determines whether the learner completes the course). If a learner fails a scored quiz, they can't complete the course, so if completion matters more than strict assessment, set it to allow unlimited retries. AI can generate a full quiz from your course content or a prompt, and every question is editable afterwards.

How do I show leadership that the training is actually working?

Insights give you three views for any course: a course summary (views and overall completion rate), a progression funnel (how far people get and where they drop off), and individual usage (who took it, how long they spent, and how far they got). You set the date range, so you can compare a recent period against an earlier one when reporting on progress.

You can export learner data straight from Insights to build your own summary for leadership. If you're delivering through Embed, the same data is available as read-only analytics components inside your own product, or through the tracking API for a custom view.

One distinction that matters for reporting: identified learners are tracked against whatever identifier you provide, an email address on self-serve sharing, or a stable identifier from your own system (typically a user ID) if you're delivering through Embed, which is what you need for compliance-style reporting ("who's completed mandatory training"). It isn't necessarily a name, just something that ties activity back to a specific person in your own system. Anonymous activity is still counted, but isn't tied to anyone at all.

If you want this to happen automatically rather than pulling a report manually each week, webhooks notify your own systems the moment someone starts or completes a course, so you can build things like an automatic reminder to non-completers or a recurring summary for management on your end, rather than checking Coassemble manually each time.

Can I export training data to build my own reports?

Yes. Export learner data from Insights, or pull it through the tracking API for a custom view.

Can leadership see results without logging into Coassemble?

Yes: embed a read-only analytics dashboard in your own product, or export the data and present it wherever leadership already looks at reporting.

Does it matter if learners are anonymous or identified for reporting?

Yes. Identified learners are tracked against an identifier, your own system's user ID if you're on Embed, or an email address on self-serve sharing, which is what compliance-style reporting needs. Anonymous activity is counted but not attributed to anyone.

Can we send automatic reminders to people who haven't finished a course?

Not as a built-in feature of the platform itself, but the pieces are there to build it. Webhooks tell your systems the moment someone starts or completes a course, so you can compare that against who was meant to take it and trigger a reminder email through your own systems for anyone who hasn't shown up as complete.

Can we issue completion certificates?

Same pattern. It's not a native feature, but the course.completed webhook gives your systems the learner's details the moment they finish, which you can use to trigger certificate generation through your own tooling or a dedicated certificate service.

Working with your technical team

I'm not technical. What do I actually need to know about Embed, and what do I tell my technical team?

Two different jobs are involved here, and only one needs technical involvement. Building and editing courses, quizzes, translations, and your brand kit don't require your technical team. Putting Coassemble inside your own product or website (so training appears embedded under your branding rather than sending people to a separate Coassemble link) is the part that needs one, and it's a defined, one-time integration rather than an ongoing build.

Here's what that involves, in plain terms, so you can brief your technical team accurately:

1. They'll need a workspace API key. This is the credential that lets your product talk to Coassemble. It's kept on your server, never exposed in the browser.
2. They choose how to build it. Coassemble provides ready-made components (a course player, a collection player, a course builder for authoring, and analytics dashboards) that drop into your product like an iframe. Alternatively, they can build a fully custom interface directly against the API, or mix both. Most teams start with the ready-made components and reach for the API only where they want more control over a specific part.
3. Each time someone opens a course, your product requests a signed link from Coassemble scoped to that person, and renders it in your app. Learners never see Coassemble's interface or sign in separately. Everything appears under your branding, on your own domain.
4. Your product listens for events Coassemble sends back (a session starting, a course updating, someone making progress or finishing), so your own dashboards can reflect status without your team having to build that tracking from scratch.

The one thing worth sending your technical team before anything else is the developer documentation, it has the full API reference, authentication setup, webhooks, and code samples, and it's built for them to scope the work themselves rather than you having to translate requirements blind.

Once it's built, this isn't a high-maintenance relationship. The main ongoing involvement is watching release notes and a status page for anything that affects the integration, not rebuilding it regularly. You will want to ensure someone from your development team is signed up to your workspace to ensure they receive our updates.

What can my team do without any technical involvement at all?

Everything involved in actually creating training: building courses, quizzes, translations, and brand settings. Technical involvement is only needed for embedding Coassemble inside your own product. You can easily export a SCORM if you have an existing LMS and would like to immediately start using our authoring tool.

Will learners see Coassemble's branding, or ours?

With Coassemble Embed, you can brand all your courses so they look like your brand. The embedded experience is rendered under your branding on your own domain, and learners don't sign into Coassemble separately or see its interface.

Does our technical team need to maintain this on an ongoing basis?

Not heavily. Once it's integrated, the main ongoing task is staying aware of release notes and platform status for anything that touches the integration, rather than continuous rebuilding.

What does implementation actually involve, and where does my responsibility end and my technical team's begin?

The two halves are cleaner than they feel from the outside. Here's the actual split:

You (Training & Content)	Your technical team
Define the use case: what training, for whom, delivered where	Requests the API key and sets up authentication
Build and edit courses, quizzes, translations, brand voice	Chooses which embeddable components to use, or builds against the API directly
Review AI-written content before it publishes	Requests signed links and renders them in your product
Approve how the branded experience looks and reads	Sets up listening for events (progress, completion) to feed your own dashboards
Decide what "done" looks like for the pilot	Handles the one-time integration work and ongoing technical maintenance

Nobody on your side needs to touch code, and nobody on the technical side needs to make instructional design decisions. The handoff point is simple: content and configuration are yours, wiring it into your product is theirs.

What to have ready before kickoff

Coming in with these answers ready speeds things up considerably:

• What you're embedding into. Do you have an existing product, app, or website this needs to live inside?
• Who's doing the technical work. Internal developer, an existing technical team, or an external developer/agency you'll bring in for the project.
• Roughly how many people will use it. Not an exact number, just a sense of scale, since it shapes how the integration gets scoped.
• What the training actually needs to do. The clearer the use case, the faster the technical side can be scoped and estimated.

How much of my own time does this actually take?

Your time goes into defining the use case, building and reviewing course content, and approving how the branded experience looks, not into the technical build itself. The technical work happens in parallel with, not instead of, your content work.

Roughly how much actual development time does a basic integration take?

The hands-on development work itself tends to be small. In real conversations, a basic integration, embedding a course player and syncing completion data back, has been described as taking anywhere from half a day to about a week for a developer already comfortable working with APIs, sometimes broken down as a couple of hours of initial scoping followed by a day or two of actual build. More involved integrations (several embeddable components, deeper use of the API, custom interface work) take longer, but the pattern holds: the coding itself is rarely the bottleneck, getting consistent time on your technical team's calendar usually is.

Will my technical team be figuring this out alone from documentation?

No. Alongside the developer documentation, there's a structured kickoff and check-in process, so your technical team has someone to ask rather than working from the docs in isolation.

Frequently asked questions

Do we need a technical team to build and publish courses?

No. Transforming a document, building quizzes, setting up translations, and managing the Brand kit all happen inside the course builder itself. A technical team only becomes relevant if you want to embed course creation inside your own product or website.

Will AI-written content sound like generic AI writing?

Not if you set brand voice first. Tone, personality and writing style are configured in the Brand kit before AI writes anything, and everything it produces can still be edited afterwards.

How is this different from building courses in Articulate?

Articulate (Storyline, Rise) gives trained instructional designers deep control over interactivity, branching and custom animation, and it's a reasonable choice if that's the skill set on your team and the course needs that level of custom design. Coassemble takes a different approach: AI structures a course from a document or prompt in minutes, so people without instructional design training can build a working course, and reserves manual, screen-by-screen building for when you want that level of control. The trade-off is that Coassemble doesn't offer Articulate's depth of custom branching interactions. If your team is migrating existing Articulate courses across, plain text, images, video and simple quiz questions carry over with minimal rework. Complex Storyline interactions, like branching scenarios and animated triggers, don't have a direct equivalent and need to be rebuilt using Coassemble's screen-based authoring instead.

Should we migrate everything from our old system at once?

No. Audit what you actually have, migrate high-priority courses first, and use the move as a chance to retire content nobody uses anymore rather than porting the whole library in one go.

Does Coassemble caption our videos for us?

No. If you're embedding video from YouTube or Vimeo, caption it on that platform first. Directly uploaded video isn't auto-captioned by Coassemble.