Australian early childhood educators are required to document children's learning against the Early Years Learning Framework. In practice that means writing Learning Stories: structured observations of what a child did, an analysis of the learning it demonstrates, and concrete next steps — written to a professional standard, and readable by parents.

It is genuinely skilled writing, and it competes for time with actually supervising children. Existing tools in this space help educators store and share observations, but the path from a hurried note taken on the floor of a playroom to a finished, framework-aligned, parent-ready story is still mostly manual.

This is a product I designed and built end to end: the product decisions, the information architecture, the AI pipeline, the data model, the interface, and the production deployment.

The most interesting part of the role was not the code but the constraint design — deciding what the AI is allowed to write, how the system behaves when it fails, and which of the many possible features actually shorten the path from observation to finished story.

Benchmarking against established products in the category showed they were strong at storage and family communication, but that the specific chain — capture an observation, produce a professional written story, hand it to a parent — was longer than it needed to be. Shortening that chain became the product thesis.

The second finding shaped the AI design. Early childhood documentation has explicit conventions: write in third person, record only what was observable, avoid interpreting a child's emotional state, and tie learning to named framework outcomes with evidence. A general-purpose model does almost the opposite by default. Meeting the convention was going to require constraint, not prompting alone.

A third observation came from watching how the writing actually happens: rarely in one sitting, often interrupted. Any wizard that lost state on interruption would be abandoned regardless of output quality.

A single web workbench with two core surfaces — Learning Stories and weekly teaching plans — supported by a shared activity library, drafts that survive interruption, and output pages designed to be copied or printed for families.

The Learning Story wizard was reduced from eight steps to six, structured so the educator supplies observable facts and the system does the professional writing. The output is deliberately three separate sections rather than one block of prose, each independently editable, because educators want to accept the structure and adjust the wording.

The generation pipeline runs three calls in sequence, each with its own constraints. The observation prompt forbids emotional and evaluative language and requires third-person observable fact. Because instructions alone are not reliable enough, generated text is then scanned for a banned vocabulary — warm adjectives that would fail a professional review — and regenerated once with a corrective instruction if any are found.

The analysis stage receives the full framework knowledge base and is required to produce a constrained structure: one to three outcomes, each with an evidence-based rationale and a cited sub-outcome, in a fixed format the interface can parse reliably.

Every section passes a completeness gate before it is accepted. If a section fails, a deterministic template built from the educator's own captured inputs is used instead, and the response is marked as having come from the fallback. The educator never sees a half-written story — which was the single most important reliability property for a tool people are meant to trust with professional documentation.

A twenty-two case end-to-end regression suite covers the combinations that matter: different age bands, different activity types, short and long observations, optional fields present and absent, and stories with and without photographs. Each case asserts that all sections are present and pass their length gates.

Draft behaviour is tested as its own flow — save, close, reopen, and confirm that free-text fields, selections, images and step position all return. The inline edit path has its own coverage, added after a production defect made clear why it needed it.

Accessibility was implemented alongside rather than retrofitted: keyboard reachability, visible focus rings, ARIA labelling, mobile-first layout, and live-region announcements while generation is running.

One abstraction can be worth a great deal when it sits at a genuine seam. The data driver interface exists because local development and production have irreconcilable persistence needs — and because it exists, moving between them costs nothing in business code. That is the shape of an abstraction that pays for itself.

Constraining AI output is product work, not prompt tuning. The professional standard was reached through a combination of instruction, a domain knowledge base, post-generation filtering, per-section quality gates and deterministic fallbacks — five mechanisms, because any one of them alone is unreliable.

Most of what I now do differently came from production rather than from design. Whether a platform merges or replaces configuration, whether a credential expires, which environment source wins, and whether a partial update is really partial are not questions that occur to you at the whiteboard.