Notebook grading tools have made computational assessment practical for many
courses. They often rely on a trusted coordinator: assignment state outside the
notebook, kernels as backend sessions, and release, submission, collection, and
grading mediated by a server or shared course directory.

That model remains useful. JupyterLite changes the constraint. If the UI,
kernels, and student workflow can run locally in the browser, what still needs
a grading backend?

Here, "serverless" means no grading backend: no separate rubric service, no
assignment-state database, and no server-side job queue coordinating kernels.
The browser and notebook do the work. The LMS supplies authority when identity,
delivery, deadlines, or receipts must come from outside the document.

The design has four parts:

• Notebook: the file stores rubric state, assignment identity,
  lifecycle timestamps, score reports, and integrity checks in metadata.
• Command: the frontend exposes commands; UI components execute
  commands; commands update the model through a workbook abstraction.
• Pipeline: scanning, distribution, grading, review, and collection are
  cold async-generator workflows pulled by the UI.
• Lease: batch grading uses a bounded pool of Jupyter kernels, so
  concurrency is explicit and language kernels stay first-class.

The security model is modest and explicit. Browser cryptography can protect
hidden references, rosters, authored state, and sealed submissions. It cannot
make a local timestamp authoritative or replace LMS access control. The talk
draws that line carefully.

The demo will use SQL because a database exercise makes the kernel-agnostic
shape visible: the grader compares structured Jupyter outputs from a student's
query against encrypted reference outputs from the instructor's query. Python
is not the hidden default.

Attendees will leave with reusable patterns for notebook-contained state,
plugin authority boundaries, kernel leasing, cold async pipelines, and frontend
cryptography.

Proposed outline:

• JupyterLite, an LMS, and no grading server
• Notebook as durable assessment artifact
• Metadata, commands, and immutable rubric state
• Cold pipelines and bounded kernel leasing
• Browser crypto and LMS authority boundaries
• Live SQL-kernel grading demo
• Limitations and questions

Expected background: basic familiarity with Jupyter notebooks and kernels.