Earning Continuing Education and College Credits Through AI Educator Training

Earning Continuing Education and College Credits Through AI Educator Training

A certificate of completion is not a credit. That single distinction explains why so many educators finish an AI training series with a folder of PDFs and still cannot answer the only question their district, licensing board, or registrar will ask: what does this count for?

Google's education team has published a pathway for educators who want their AI training to count toward continuing education and college credit, described on the Google blog at https://blog.google/products-and-platforms/products/education/college-credit-ai-educator-series. This article treats that page as the authoritative starting point, explains how credit conversion generally works, and then walks through a small, locally installed ledger that keeps your evidence packet audit-ready before you need it.

What the Source Establishes — and What It Does Not

The verified primary source is Google's own education blog page describing how educators can earn continuing education and college credits for AI educator training. That is the scope of the evidence available here.

What the page does not establish — at least not in a form this article can responsibly assert — includes specific credit-hour totals, tuition or fee amounts, the identity of credit-granting partner institutions, state-by-state acceptance rules, or enrollment deadlines. Those are exactly the details that change most often and that vary most by jurisdiction. Read them directly from the source page and from the credit-granting institution before you pay for anything or promise your principal a number.

The practical consequence: treat the Google page as the front door, not the contract. Your eligibility, your cost, and your transcript outcome are governed by the credit provider and by your own state or district policy.

Three Currencies, Three Different Approvals

"Credit" is not one thing. In practice, educators encounter three distinct currencies, and a single training series can convert into some, all, or none of them depending on the provider.

Continuing education units (CEUs) are typically awarded by a training provider or an accredited institution and are used to satisfy license renewal or salary-lane requirements. They are usually the easiest to obtain and the least portable. Many U.S. providers use a convention of roughly ten contact hours per CEU, but that convention is not universal, and it is not something the source page guarantees for any particular series. Confirm the provider's formula in writing.

Graduate credit is issued by a university, often through a school of education, and generally requires both the training hours and an additional deliverable — a reflective paper, a portfolio, or an applied classroom project. Graduate credit is more expensive and more transferable.

Undergraduate credit appears less often in professional-development contexts but shows up in degree-completion pathways and in prior-learning assessment petitions, where a portfolio is evaluated against a course's learning outcomes rather than against seat time.

This three-way split is general practice, not a claim drawn from the source. Its value is diagnostic: when someone tells you a training "counts for credit," your next question should be which currency, issued by whom, and accepted by which authority.

Requirements

Before installing anything, confirm that you can satisfy the documentation requirements. The tooling below is a ledger; it cannot manufacture evidence you never collected.

• A completed training component. The AI educator training series referenced by the source page, or an equivalent program you have already finished.
• Provider documentation. A certificate of completion, plus a syllabus or agenda that states contact hours explicitly. An agenda without hours is the single most common reason a submission is rejected.
• An accreditation or approval statement. A document showing the provider is authorized to issue the credit type you are claiming.
• An artifact of practice. A lesson plan, unit redesign, or classroom assessment that shows you applied the training. Graduate credit reviewers ask for this almost every time.
• Institutional rules. Your district's professional-development policy, your state licensure renewal requirements, and — if you are pursuing college credit — the registrar's or prior-learning office's petition format.
• Local technical requirements. Python 3.10 or newer, pip, Git, and roughly 50 MB of disk space. Any of Windows, macOS, or Linux works.

Step-by-step installation

The goal is a single directory that holds your records, validates them, and renders a submission-ready summary. Work through the steps in order.

First, confirm your Python version is new enough for the type-hint syntax used below.

python3 --version

Create the project directory and its subdirectories in one command, so records, templates, and generated output stay separated.

mkdir -p ai-credit-ledger/{records,templates,output} && cd ai-credit-ledger

Initialize a Git repository so every change to your ledger is versioned and timestamped — useful if a reviewer questions when a record was added.

git init && git branch -M main

Create a virtual environment to isolate the two dependencies you are about to install.

python3 -m venv .venv

On macOS or Linux, activate the environment with the shell script it just created.

source .venv/bin/activate

On Windows PowerShell, the equivalent activation command is a different path.

py -3 -m venv .venv; .\.venv\Scripts\Activate.ps1

Upgrade pip before installing anything, which avoids resolution errors on older bootstrapped versions.

python -m pip install --upgrade pip

Install the two libraries the ledger uses: PyYAML is not required, but Jinja2 renders the HTML summary and rich produces readable terminal output for validation failures.

pip install jinja2 rich

Freeze the resolved versions so your setup is reproducible if you move it to a district laptop.

pip freeze > requirements.txt

Now create the ledger script itself.

touch ledger.py

Open ledger.py and paste the following. It defines a record structure, validates each entry against a documentation checklist, and renders a summary.

#!/usr/bin/env python3
"""Track AI educator training hours and assemble a credit-ready evidence packet."""

from __future__ import annotations

import argparse
import csv
import sys
from dataclasses import dataclass, field
from datetime import date
from pathlib import Path

from jinja2 import Environment, FileSystemLoader
from rich.console import Console

ROOT = Path(__file__).resolve().parent
LOG_PATH = ROOT / "records" / "training-log.csv"
TEMPLATE_DIR = ROOT / "templates"
OUTPUT_PATH = ROOT / "output" / "credit-summary.html"

# Confirm your provider's convention before relying on this divisor.
CONTACT_HOURS_PER_CEU = 10.0
REQUIRED_DOCS = ("certificate", "syllabus", "agenda", "accreditation")

console = Console()


@dataclass
class Entry:
    completed_on: date
    title: str
    provider: str
    hours: float
    credit_type: str
    docs: list[str] = field(default_factory=list)

    @property
    def missing_docs(self) -> list[str]:
        return [d for d in REQUIRED_DOCS if d not in self.docs]

    @property
    def ceu(self) -> float:
        return self.hours / CONTACT_HOURS_PER_CEU if self.credit_type == "ceu" else 0.0


def load(path: Path) -> list[Entry]:
    if not path.exists():
        console.print(f"[red]Missing ledger file:[/red] {path}")
        sys.exit(2)
    entries: list[Entry] = []
    with path.open(newline="", encoding="utf-8") as handle:
        for row in csv.DictReader(handle):
            entries.append(
                Entry(
                    completed_on=date.fromisoformat(row["completed_on"].strip()),
                    title=row["title"].strip(),
                    provider=row["provider"].strip(),
                    hours=float(row["hours"]),
                    credit_type=row["credit_type"].strip().lower(),
                    docs=[d.strip().lower() for d in row["docs"].split("|") if d.strip()],
                )
            )
    return entries


def validate(entries: list[Entry]) -> int:
    failures = 0
    seen: set[tuple[str, str]] = set()
    for entry in entries:
        problems = []
        if entry.hours <= 0:
            problems.append("hours must be positive")
        if entry.missing_docs:
            problems.append(f"missing documents: {', '.join(entry.missing_docs)}")
        key = (entry.title.lower(), entry.provider.lower())
        if key in seen:
            problems.append("duplicate title/provider pair")
        seen.add(key)
        if problems:
            failures += 1
            console.print(f"[yellow]{entry.title}[/yellow] -> {'; '.join(problems)}")
        else:
            console.print(f"[green]OK[/green] {entry.title}")
    return failures


def report(entries: list[Entry], output: Path) -> None:
    env = Environment(loader=FileSystemLoader(TEMPLATE_DIR), autoescape=True)
    template = env.get_template("summary.html.j2")
    total_hours = sum(e.hours for e in entries)
    total_ceu = sum(e.ceu for e in entries)
    output.parent.mkdir(parents=True, exist_ok=True)
    output.write_text(
        template.render(
            entries=entries,
            total_hours=total_hours,
            total_ceu=total_ceu,
            complete=all(not e.missing_docs for e in entries),
        ),
        encoding="utf-8",
    )
    console.print(f"[green]Wrote[/green] {output}")


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("command", choices=("validate", "report"))
    args = parser.parse_args()

    entries = load(LOG_PATH)
    if args.command == "validate":
        failures = validate(entries)
        return 1 if failures else 0
    report(entries, OUTPUT_PATH)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

Save the file, then create the ledger with its header row.

printf 'completed_on,title,provider,hours,credit_type,docs\n' > records/training-log.csv

Create the HTML template that the report command renders.

touch templates/summary.html.j2

Paste this template into the new file. It prints a completeness flag, then a table of every entry with its CEU equivalent.

<!doctype html>
<html lang="en">
<head><meta charset="utf-8"><title>AI Training Credit Summary</title></head>
<body>
  <h1>AI Educator Training — Credit Summary</h1>
  <p>Total contact hours: <strong>{{ total_hours }}</strong> ·
     Estimated CEUs: <strong>{{ "%.2f"|format(total_ceu) }}</strong></p>
  <p>Documentation complete for all entries: <strong>{{ complete }}</strong></p>
  <table border="1" cellpadding="6">
    <tr><th>Date</th><th>Title</th><th>Provider</th><th>Hours</th>
        <th>Type</th><th>Documents</th></tr>
    {% for e in entries %}
    <tr>
      <td>{{ e.completed_on }}</td><td>{{ e.title }}</td><td>{{ e.provider }}</td>
      <td>{{ e.hours }}</td><td>{{ e.credit_type }}</td>
      <td>{{ e.docs|join(", ") }}{% if e.missing_docs %} — MISSING: {{ e.missing_docs|join(", ") }}{% endif %}</td>
    </tr>
    {% endfor %}
  </table>
</body>
</html>

Usage examples

Add a completed training record. The docs column uses pipe-separated labels matching the four required document types.

echo '2026-01-15,AI Educator Series Module 1,Example Provider,6,ceu,certificate|syllabus|agenda' >> records/training-log.csv

Run validation. The process exits with status 1 when any entry fails, which makes it usable in a pre-submission script.

python ledger.py validate

Generate the HTML summary from the same records.

python ledger.py report

Open the generated file in a browser. On macOS the command is open; on Linux use xdg-open; on Windows use start.

open output/credit-summary.html

A realistic run surfaces the gap immediately. The record above is missing the provider's accreditation statement, so validation prints that entry in yellow and names the missing document. That is the point: you find the hole in your packet while you can still email the provider, not after the registrar's deadline.

For graduate credit, pair the ledger output with a short narrative. Reviewers want a plain statement of what you learned, what you changed in your classroom, and how the change was assessed. Keep it to one page and attach the artifact. The HTML summary is the index; the narrative is the argument.

Documentation That Survives Review

Three habits separate packets that get approved from packets that get bounced.

Name files with the date and the claim they support — 2026-01-15_certificate_ai-educator-module-1.pdf — rather than IMG_4471.pdf. Reviewers process dozens of submissions.

Match hours to a source. If the syllabus says six contact hours and your ledger says six, the review is trivial. If they disagree, you have created a dispute you will probably lose.

Keep the accreditation statement current. Providers occasionally change or lose their authorization to issue a given credit type. A statement from the year you enrolled may not be accepted for a submission you file later, and it is worth confirming directly with the provider.

Common Failure Modes

The most frequent problem is treating a completion certificate as sufficient. It documents attendance, not contact hours, and it rarely states the credit type.

The second is assuming portability. CEUs approved in one state or by one district are not automatically accepted elsewhere, and nothing in the source page overrides local rules.

The third is retroactive timing. Many credit pathways require you to request credit within a defined window after completing the training. If you finish a series and file the paperwork a year later, you may be outside it.

Open Questions and Limits

This article cannot tell you what the Google pathway costs, how many credits it yields, which institution issues them, or whether your state accepts them. Those facts live with the provider and your licensing authority, and they change. The ledger described here organizes whatever those answers turn out to be; it does not substitute for them.

Nor does documentation guarantee approval. Credit decisions are discretionary, made by a registrar, a state board, or a district committee applying criteria you may not see. Strong evidence raises your odds. It does not remove the decision-maker.

Conclusion

The distance between finishing AI educator training and holding a credit is a documentation problem, and documentation problems are solvable in advance. Start from the Google education page for the pathway itself, confirm the credit type and provider with the issuing institution, and collect the four documents — certificate, syllabus or agenda, accreditation statement, and artifact — as you go rather than after the fact. Then keep a local ledger like the one above so that when the submission window opens, you are exporting a report instead of reconstructing a semester.