DEV Community: Aditya Tiwari

Automated Testing for SCORM E-Learning Packages Using Playwright — A Step-by-Step Guide

Aditya Tiwari — Thu, 11 Jun 2026 21:44:24 +0000

Most testing tutorials ignore e-learning completely. Here's how to build a Playwright test suite that validates your SCORM packages actually work across LMS platforms.

Why E-Learning Testing Is Different

If you've ever published a SCORM package to an LMS and watched it silently fail — no completion recorded, quiz scores vanishing, navigation broken — you know the pain. E-learning content doesn't behave like a typical web app. It runs inside an LMS-provided iframe, communicates through a JavaScript API (the SCORM Runtime), and its behavior changes depending on which LMS hosts it.

Manual QA across even 3-4 LMS platforms is slow and error-prone. In this tutorial, I'll walk you through setting up Playwright to automate SCORM package testing — from basic content loading to verifying API calls and completion status.

Prerequisites

Before we start, make sure you have:

Node.js 18+ installed
Playwright (npm init playwright@latest)
A SCORM 1.2 or 2004 package (a .zip file containing your e-learning content)
A local LMS for testing — we'll use SCORM Cloud (free tier) or a simple SCORM API shim

Step 1: Set Up a Local SCORM Runtime Shim

Testing SCORM content requires an API that mimics what an LMS provides. Rather than spinning up a full Moodle instance, we'll create a lightweight shim.

Create a file called scorm-api-shim.js:

// scorm-api-shim.js
// Mimics the SCORM 1.2 Runtime API that an LMS would expose

window.API = {
  _data: {},
  _initialized: false,
  _calls: [],

  LMSInitialize: function(param) {
    this._initialized = true;
    this._calls.push({ method: 'LMSInitialize', param, timestamp: Date.now() });
    console.log('[SCORM] LMSInitialize called');
    return "true";
  },

  LMSGetValue: function(key) {
    this._calls.push({ method: 'LMSGetValue', key, timestamp: Date.now() });
    return this._data[key] || "";
  },

  LMSSetValue: function(key, value) {
    this._data[key] = value;
    this._calls.push({ method: 'LMSSetValue', key, value, timestamp: Date.now() });
    console.log(`[SCORM] SetValue: ${key} = ${value}`);
    return "true";
  },

  LMSCommit: function(param) {
    this._calls.push({ method: 'LMSCommit', param, timestamp: Date.now() });
    return "true";
  },

  LMSFinish: function(param) {
    this._calls.push({ method: 'LMSFinish', param, timestamp: Date.now() });
    this._initialized = false;
    return "true";
  },

  LMSGetLastError: function() { return "0"; },
  LMSGetErrorString: function(code) { return "No error"; },
  LMSGetDiagnostic: function(code) { return ""; }
};

This gives us a mock API that logs every SCORM call — which becomes our test assertion layer.

Step 2: Serve the SCORM Package Locally

Unzip your SCORM package and serve it with a simple HTTP server. Create serve-scorm.js:

// serve-scorm.js
const express = require('express');
const path = require('path');
const app = express();

// Serve the SCORM API shim at the parent level (LMS frame)
app.get('/lms', (req, res) => {
  res.send(`
    <!DOCTYPE html>
    <html>
    <head>
      <title>Test LMS</title>
      <script src="/scorm-api-shim.js"></script>
    </head>
    <body>
      <iframe id="content-frame" 
              src="/scorm-content/index.html" 
              width="100%" 
              height="600px">
      </iframe>
    </body>
    </html>
  `);
});

app.use('/scorm-api-shim.js', express.static(path.join(__dirname, 'scorm-api-shim.js')));
app.use('/scorm-content', express.static(path.join(__dirname, 'unzipped-scorm-package')));

app.listen(3000, () => console.log('Test LMS running at http://localhost:3000/lms'));

Run it:

npm install express
node serve-scorm.js

Visit http://localhost:3000/lms — you should see your SCORM content loaded inside the iframe, with API calls logging in the console.

Step 3: Write Your First Playwright Test — Content Loads and Initializes

Create your test file at tests/scorm-basic.spec.js:

// tests/scorm-basic.spec.js
const { test, expect } = require('@playwright/test');

test.describe('SCORM Package - Basic Validation', () => {

  test('should load content and call LMSInitialize', async ({ page }) => {
    await page.goto('http://localhost:3000/lms');

    // Wait for the content iframe to load
    const frame = page.frameLocator('#content-frame');
    await frame.locator('body').waitFor({ state: 'visible' });

    // Check that LMSInitialize was called
    const initCalled = await page.evaluate(() => {
      return window.API._calls.some(c => c.method === 'LMSInitialize');
    });

    expect(initCalled).toBe(true);
  });

  test('should set lesson_status to incomplete or browsed on load', async ({ page }) => {
    await page.goto('http://localhost:3000/lms');

    const frame = page.frameLocator('#content-frame');
    await frame.locator('body').waitFor({ state: 'visible' });

    // Give the content a moment to make its initial API calls
    await page.waitForTimeout(2000);

    const lessonStatus = await page.evaluate(() => {
      return window.API._data['cmi.core.lesson_status'];
    });

    // SCORM content typically sets status to 'incomplete' or 'browsed' on launch
    expect(['incomplete', 'browsed', 'not attempted']).toContain(lessonStatus);
  });

});

Run the test:

npx playwright test tests/scorm-basic.spec.js

Step 4: Test Quiz Interaction Tracking

If your SCORM package has a quiz, you need to verify that interaction data is being recorded correctly. This is where most LMS compatibility bugs live.

// tests/scorm-quiz.spec.js
const { test, expect } = require('@playwright/test');

test.describe('SCORM Package - Quiz Interactions', () => {

  test('should record interaction data when answering a quiz question', async ({ page }) => {
    await page.goto('http://localhost:3000/lms');

    const frame = page.frameLocator('#content-frame');

    // Navigate to the quiz slide (adjust selectors to your content)
    // This will vary based on your authoring tool's output
    await frame.locator('[data-slide="quiz-1"]').click();

    // Select an answer
    await frame.locator('.answer-option').first().click();

    // Submit the answer
    await frame.locator('.submit-btn').click();

    // Verify interaction was recorded via SCORM API
    const interactions = await page.evaluate(() => {
      return window.API._calls.filter(c => 
        c.method === 'LMSSetValue' && 
        c.key.startsWith('cmi.interactions')
      );
    });

    // Should have at least one interaction recorded
    expect(interactions.length).toBeGreaterThan(0);

    // Verify the interaction has a valid type
    const interactionType = interactions.find(i => i.key.includes('.type'));
    expect(['choice', 'true-false', 'fill-in', 'matching', 'sequencing'])
      .toContain(interactionType?.value);
  });

  test('should calculate and commit score after quiz completion', async ({ page }) => {
    await page.goto('http://localhost:3000/lms');

    // ... navigate through quiz and answer all questions ...

    // After completing the quiz, check for score
    const scoreRaw = await page.evaluate(() => {
      return window.API._data['cmi.core.score.raw'];
    });

    const scoreMax = await page.evaluate(() => {
      return window.API._data['cmi.core.score.max'];
    });

    // Score should be a valid number
    expect(Number(scoreRaw)).not.toBeNaN();
    expect(Number(scoreMax)).toBeGreaterThan(0);
    expect(Number(scoreRaw)).toBeLessThanOrEqual(Number(scoreMax));

    // Verify LMSCommit was called after scoring
    const commitCalls = await page.evaluate(() => {
      return window.API._calls.filter(c => c.method === 'LMSCommit');
    });
    expect(commitCalls.length).toBeGreaterThan(0);
  });

});

Step 5: Test Completion and Finish Sequence

The most common SCORM bug: content that never calls LMSFinish or sets lesson_status to completed/passed. This breaks LMS reporting.

// tests/scorm-completion.spec.js
const { test, expect } = require('@playwright/test');

test.describe('SCORM Package - Completion Flow', () => {

  test('should set lesson_status to completed/passed after full navigation', async ({ page }) => {
    await page.goto('http://localhost:3000/lms');

    const frame = page.frameLocator('#content-frame');

    // Navigate through all slides (adjust to your content structure)
    const nextButton = frame.locator('.next-btn, [aria-label="Next"]');

    let hasNext = true;
    while (hasNext) {
      try {
        await nextButton.click({ timeout: 3000 });
        await page.waitForTimeout(500);
      } catch {
        hasNext = false;
      }
    }

    // Check final lesson status
    const finalStatus = await page.evaluate(() => {
      return window.API._data['cmi.core.lesson_status'];
    });

    expect(['completed', 'passed']).toContain(finalStatus);
  });

  test('should call LMSFinish on content exit', async ({ page }) => {
    await page.goto('http://localhost:3000/lms');

    // Navigate through content...
    // Then close or navigate away
    await page.evaluate(() => {
      // Simulate unload event
      window.dispatchEvent(new Event('beforeunload'));
    });

    await page.waitForTimeout(1000);

    const finishCalled = await page.evaluate(() => {
      return window.API._calls.some(c => c.method === 'LMSFinish');
    });

    expect(finishCalled).toBe(true);
  });

});

Step 6: Generate a SCORM API Call Report

The real power of this approach is the ability to dump every SCORM API call for debugging. Add this utility:

// tests/helpers/scorm-report.js
async function generateSCORMReport(page) {
  const calls = await page.evaluate(() => window.API._calls);
  const data = await page.evaluate(() => window.API._data);

  console.log('\n=== SCORM API Call Log ===');
  calls.forEach((call, index) => {
    const time = new Date(call.timestamp).toISOString().split('T')[1];
    if (call.key) {
      console.log(`${index + 1}. [${time}] ${call.method}("${call.key}"${call.value ? ', "' + call.value + '"' : ''})`);
    } else {
      console.log(`${index + 1}. [${time}] ${call.method}()`);
    }
  });

  console.log('\n=== Final SCORM Data Model ===');
  Object.entries(data).forEach(([key, value]) => {
    console.log(`  ${key}: ${value}`);
  });

  return { calls, data };
}

module.exports = { generateSCORMReport };

Use it in your tests:

const { generateSCORMReport } = require('./helpers/scorm-report');

test.afterEach(async ({ page }) => {
  await generateSCORMReport(page);
});

Step 7: Run Across Multiple Browser Contexts (Simulating Different LMS Environments)

Different LMS platforms use different iframe embedding strategies. Test your content across configurations:

// playwright.config.js
module.exports = {
  projects: [
    {
      name: 'chromium-default',
      use: { browserName: 'chromium' },
    },
    {
      name: 'firefox',
      use: { browserName: 'firefox' },
    },
    {
      name: 'webkit-safari',
      use: { browserName: 'webkit' },
    },
  ],
};

Run all:

npx playwright test --reporter=html

This gives you a visual HTML report showing pass/fail across browsers — which maps roughly to how your content will behave across different LMS platforms that use different embedded browser engines.

What This Gets You

With this setup, you can now:

Catch SCORM API bugs before publishing — missing LMSInitialize, broken completion triggers, invalid interaction data
Debug LMS-specific failures by examining the full API call log
Run regression tests every time content is updated or the authoring tool ships a new version
Automate cross-browser validation that would take hours to do manually

In our team, this approach cut QA time for SCORM packages by roughly 70% and caught a category of bugs — specifically, race conditions in LMSSetValue calls during quiz scoring — that manual testing had missed for months.

Next Steps

From here, you can extend this framework to:

Test SCORM 2004 packages (replace window.API with window.API_1484_11)
Test xAPI (Tin Can) statements by intercepting fetch/XMLHttpRequest calls to the LRS endpoint
Integrate into CI/CD with GitHub Actions so every content build gets validated automatically
Add accessibility checks using @axe-core/playwright alongside SCORM validation

If you're building or testing e-learning content and you've run into weird LMS bugs, I'd love to hear about them — the edge cases in this space are wild.

I'm a senior software engineer with 11 years in e-learning technology. I write about the tools and techniques behind enterprise content authoring. Find me on LinkedIn.

Why SCORM Refuses to Die — And What AI Finally Changes About That

Aditya Tiwari — Thu, 11 Jun 2026 21:35:59 +0000

SCORM was built in the early 2000s for a world of CD-ROMs and Flash. It's 2026 and it still runs 80%+ of corporate e-learning. Here's why, and why generative AI might be the thing that finally breaks the cycle.

SCORM Is Everywhere, and Nobody Is Happy About It

If you work anywhere near corporate learning, you've encountered SCORM — the Sharable Content Object Reference Model. It's a set of standards that lets e-learning content talk to a Learning Management System: track completion, record scores, resume where you left off.

SCORM 1.2 was released in 2001. SCORM 2004 followed a few years later. That's it. The spec hasn't meaningfully evolved in two decades.

And yet, almost every LMS on the market — Moodle, Cornerstone, SAP SuccessFactors, Docebo, Absorb — still supports SCORM as a primary content format. Most Fortune 500 compliance training runs on it. Every major authoring tool, from Adobe Captivate to Articulate Storyline to Lectora, exports SCORM packages.

It's the TCP/IP of corporate learning: unglamorous, creaky, universally understood.

Why It Won't Die: The Network Effect Nobody Talks About

People love to write "SCORM is dead" articles. I've been in e-learning engineering for 11 years and I've read that headline at least once a year since I started. SCORM isn't dead because it benefits from one of the strongest network effects in enterprise software.

Consider the ecosystem:

Authoring tools export SCORM because LMS platforms expect it.
LMS platforms support SCORM because authoring tools export it.
L&D teams require SCORM because their procurement processes mandate it.
Procurement mandates SCORM because it's the only format every vendor supports.

Breaking this cycle requires everyone to move simultaneously. That doesn't happen in enterprise software. It especially doesn't happen when "good enough" works and switching costs are invisible but enormous (repackaging thousands of courses, retraining content teams, renegotiating vendor contracts).

xAPI (Tin Can) was supposed to be the successor. It launched in 2013 with genuinely better ideas: track any learning experience, not just course completions. Learn from a YouTube video? An on-the-job simulation? A VR module? xAPI can track it all. But 13 years later, xAPI adoption in enterprise remains patchy. Most organizations that "use xAPI" are actually running it alongside SCORM, not instead of it.

Where SCORM Actually Breaks

SCORM's limitations aren't theoretical. They create real problems I've dealt with firsthand:

No concept of adaptive content. SCORM tracks linear progress through a course. It can't represent branching paths that change based on learner performance. You can hack it with creative SCO structuring, but the data model doesn't natively support "this learner saw a different version of the course than that learner."

Assessment data is shallow. SCORM records correct/incorrect and a score. It doesn't capture how a learner arrived at an answer, how long they deliberated, whether they changed their response, or what misconceptions their wrong answers reveal.

No real-time data. SCORM communicates through synchronous JavaScript calls to the LMS. There's no streaming, no real-time analytics, no ability for content to adapt mid-session based on aggregated learner data.

Single-session assumption. SCORM assumes a learner sits down, takes a course, and finishes. The modern reality — learning in 3-minute bursts on a phone between meetings — fits poorly into SCORM's session model.

Enter Generative AI — The Actual Disruption

I've been working on integrating generative AI into an enterprise authoring tool, and here's what's become clear: AI doesn't just improve SCORM-based content — it creates content that SCORM fundamentally can't describe.

AI-generated adaptive paths. When AI generates personalized learning paths based on a learner's role, prior knowledge, or real-time performance, every learner gets a different course. SCORM has no way to represent this. What's the "completion" of a course that's different for every person? What's the "score" when the questions were dynamically generated?

Conversational learning. AI tutors that engage learners in dialogue — answering follow-up questions, adjusting explanations, probing understanding — produce learning experiences that look nothing like a sequence of slides. There's no SCORM data model element for "quality of learner's follow-up question" or "number of misconceptions corrected."

Continuous assessment. Instead of a quiz at the end, AI can assess understanding continuously through the conversation. This produces a rich, continuous signal about learner comprehension. SCORM's cmi.interactions model — designed for discrete, numbered questions — can't hold this data.

Generated content versioning. If AI generates explanations or examples on-the-fly, the "content" isn't a fixed package anymore. It's a set of prompts, guardrails, and generation parameters. SCORM assumes content is a static zip file uploaded to an LMS. That mental model breaks when the content is generated at runtime.

What Actually Replaces SCORM (Probably)

Here's my bet after watching this space from the inside:

SCORM doesn't get replaced by another monolithic standard. Instead, it gets gradually hollowed out:

xAPI captures the rich data. AI-generated learning interactions get tracked as xAPI statements sent to a Learning Record Store. This is already technically possible and some forward-thinking organizations are doing it.
SCORM remains the "shipping container." For compliance and interoperability, content still gets wrapped in a SCORM package for LMS delivery. But the actual learning experience inside that package increasingly talks to external AI services and logs detailed data via xAPI, while sending SCORM only the bare minimum (completed/not completed, pass/fail).
LTI handles the launch. Learning Tools Interoperability (LTI) is already how most LMS platforms launch external tools. AI-powered learning experiences are essentially external tools — they run on their own infrastructure, with their own models, and just need a secure way to launch from the LMS and pass back a grade.

The result is a stack: LTI for launch → AI service for experience → xAPI for rich data → SCORM for legacy compliance. Nobody replaces SCORM. Everyone routes around it.

What This Means If You're Building E-Learning Tools Today

If you're an engineer or product manager working on authoring tools or LMS platforms, here's my practical advice:

Don't abandon SCORM. Your customers need it. Procurement requires it. But treat it as a packaging format, not a data model.

Invest in xAPI plumbing. Build the infrastructure to emit and consume xAPI statements alongside SCORM tracking. When AI-powered content becomes mainstream (and it will), you'll need this.

Design for content that isn't a static package. AI-generated content challenges the assumption that a "course" is a zip file. Start thinking about content as a combination of templates, prompts, guardrails, and generation parameters. Your content model needs to accommodate this.

Track what SCORM can't. Even before full xAPI adoption, start capturing richer interaction data — learner hesitation, answer changes, time-on-concept, help-seeking behavior. Store it in your own analytics layer. This data becomes the training signal for better AI tutoring.

The Bottom Line

SCORM survives because it solved an interoperability problem well enough that nobody has sufficient incentive to switch. AI doesn't kill SCORM by being a better standard — it kills it by creating learning experiences that SCORM's data model can't describe.

The transition won't be a cutover. It'll be a gradual layering: AI-powered content running inside SCORM containers, tracking data via xAPI, launched through LTI. If you're building in this space, design for that layered future now.

I'm a senior software engineer with 11 years building e-learning tools at Adobe. I write about the intersection of AI, enterprise content standards, and the messy reality of shipping software in regulated industries. Find me on LinkedIn.

Integrating Generative AI Into an Enterprise E-Learning Authoring Tool — What I Actually Learned

Aditya Tiwari — Wed, 10 Jun 2026 21:19:58 +0000

After 11 years building e-learning software at a major enterprise, here’s what surprised me when we started shipping GenAI features to real users.

The Starting Point Nobody Talks About

Most GenAI integration blog posts start with a clean slate — a greenfield app, a fresh codebase, a blank canvas. Real life is messier.

When we began integrating generative AI into our e-learning authoring tool, we weren’t starting from scratch. We were dealing with a mature enterprise product — millions of users, legacy architecture decisions made years ago, compliance requirements from Fortune 500 customers, and LMS interoperability standards (SCORM, xAPI) that were designed long before anyone imagined AI-generated content.

The challenge wasn’t “how do we call an AI API.” It was “how do we ship AI features into a product that thousands of instructional designers depend on daily, without breaking their workflows or their trust.”

Here’s what I learned.

Lesson 1: The AI Feature Your Users Want Is Not the One You Think

When we first scoped out AI integration, the engineering team gravitated toward the flashy stuff — generate an entire course from a prompt, auto-create assessments, AI-powered slide design.

Then we talked to actual users.

Instructional designers didn’t want AI to replace their expertise. They wanted it to eliminate the tedious parts of their workflow:

Reformatting content across different output types (responsive HTML5, PDF, SCORM packages)
Generating alt-text for hundreds of images in accessibility-compliant courses
Summarizing lengthy SME-provided documents into digestible learning chunks
Suggesting quiz questions from existing content (not generating courses from nothing)

The takeaway: don’t let engineering excitement drive your AI feature roadmap. Do 10 user interviews before writing a single line of integration code. The highest-impact GenAI features are usually the boring ones.

Lesson 2: Prompt Engineering Is a Product Decision, Not an Engineering Task

We initially treated prompt design as an implementation detail — something the backend team would figure out. That was wrong.

The prompts that generate content for an e-learning tool carry product-level implications:

Tone and reading level — A course for factory floor workers needs fundamentally different language than one for executives. The prompt must encode this.
Bloom’s taxonomy alignment — Assessment questions need to target specific cognitive levels (remember, understand, apply, analyze). This isn’t something you bolt on after; it shapes the entire prompt structure.
Bias and accuracy — Enterprise L&D customers have zero tolerance for hallucinated content in compliance training. We needed guardrails baked into the prompt, not just a disclaimer.

We ended up creating a “prompt design review” step in our feature development process, where product managers, instructional design consultants, and engineers collaboratively refined prompts. It added a week to each feature cycle but prevented months of post-launch fixes.

Lesson 3: LMS Interoperability Makes Everything Harder

Here’s something unique to e-learning that most AI integration guides completely ignore: your AI-generated content doesn’t just live in your tool. It gets packaged as SCORM 1.2, SCORM 2004, or xAPI content and deployed to dozens of different LMS platforms — Moodle, Cornerstone, SAP SuccessFactors, Docebo, you name it.

This creates constraints that don’t exist in other domains:

AI-generated interactive elements need to produce valid SCORM API calls. An AI that generates a drag-and-drop interaction also needs to generate the corresponding cmi.interactions tracking code.
Content structure must map to a navigable SCO (Sharable Content Object) hierarchy. You can’t just dump AI-generated HTML into a package.
Completion and scoring logic must be deterministic. If AI generates a quiz, the scoring must be unambiguous and LMS-reportable. Probabilistic or fuzzy scoring breaks compliance reporting.

We built a validation layer that sits between AI output and SCORM/xAPI packaging — essentially a “content compiler” that checks structural validity, tracking completeness, and accessibility compliance before anything gets exported.

Lesson 4: Latency Tolerance Varies Wildly by Feature

Not all AI features need to be real-time. Understanding this saved us enormous infrastructure cost.

We categorized our AI features into three latency tiers:

Tier	Example	Acceptable Latency	Approach
Instant	Smart text suggestions while typing	< 500ms	Edge-cached smaller models, pre-computed suggestions
Interactive	Generate quiz from selected content	2-8 seconds	Standard API call with streaming UI feedback
Background	Alt-text generation for 200 images in a course	Minutes	Async job queue, notification on completion

The mistake teams make is treating every AI feature as “interactive.” Your users will happily wait 5 minutes for bulk alt-text generation if you give them a progress indicator and let them keep working. But they won’t wait 3 seconds for an inline text suggestion.

Lesson 5: Enterprise Customers Ask Questions You Haven’t Considered

Before shipping AI features, be ready to answer these from procurement and IT security teams:

“Does our training content get used to train the model?” — You need a clear, documented answer. For enterprise e-learning, the content often includes proprietary processes, trade secrets, and PII. Data residency matters.
“Can we disable AI features entirely?” — Some regulated industries (healthcare, finance) may need to turn off generative features for compliance reasons. Build a kill switch from day one.
“How do we audit AI-generated content?” — Enterprise L&D teams need to know which parts of a course were AI-generated vs. human-authored, especially for compliance training that faces regulatory review.
“What happens when the AI model version changes?” — If you regenerate content with a newer model, it might differ from the previously approved version. Version pinning and content fingerprinting become essential.

We ended up building an “AI transparency layer” — metadata tagging that marks every piece of AI-generated or AI-assisted content with the model version, timestamp, and prompt used. This became one of our most valued enterprise features.

Lesson 6: Your Existing Architecture Will Fight You

Our authoring tool was built on a component architecture where content elements (text blocks, images, interactions, quizzes) were discrete, well-defined objects with schemas.

AI doesn’t naturally produce schema-compliant content. A language model generates text — converting that into structured content objects requires a translation layer that’s more complex than the AI call itself.

For example, when AI generates a quiz question, we need:

The question stem as a specific content object
Each answer option as a child object with correct/incorrect flagging
Feedback text for each option as another child object
SCORM interaction tracking metadata
Accessibility attributes (ARIA labels, reading order)

We spent roughly 40% of our AI integration effort on this “structured output” problem — and I’d bet most enterprise tools face the same ratio.

Lesson 7: Measure What Matters, Not What’s Easy

It’s tempting to measure AI feature success by adoption rates (X% of users tried the AI quiz generator). That’s vanity.

The metrics that actually mattered for us:

Time-to-publish — Did AI features reduce the average time from blank project to published course?
Revision cycles — Are AI-generated elements surviving SME review, or getting deleted/rewritten?
Accessibility compliance rate — Did AI-generated alt-text actually pass WCAG audits?
LMS compatibility — Are AI-generated interactions producing valid tracking data across LMS platforms?

After 6 months, our data showed that AI-assisted alt-text generation had an 87% first-pass acceptance rate and cut accessibility compliance time by ~60%. The “generate entire course” feature — the one engineering was most excited about — had a 23% acceptance rate and most outputs were heavily edited.

Build more of what works. Kill what doesn’t, regardless of how technically impressive it is.

The Bottom Line

Integrating GenAI into an enterprise product isn’t a model problem — it’s a systems problem. The AI call is 10% of the work. The other 90% is:

Understanding your users’ actual pain points
Respecting existing standards and interoperability requirements
Building guardrails, audit trails, and kill switches
Designing the translation layer between AI output and your product’s content model
Measuring real impact, not usage vanity metrics

If you’re working on AI integration for any mature enterprise product — especially in e-learning, healthcare, or regulated industries — I’d love to hear what you’ve run into. The challenges are more similar than you’d think.