Selected work

Engineering case study / 01

Story Filler

From a local platform lab
to a smaller cloud operating model.

A story-based learning app becomes a practical study in infrastructure, architectural trade-offs and verified delivery.

Focus Infrastructure & delivery
Context Course project → personal practice
Latest release verification 3 November 2026

01 / Project & contribution

Architecture, delivery
and engineering judgment.

Story Filler combines Māori stories, a word bank, illustrations and pronunciation audio. It connects a React frontend, Django API and administration, PostgreSQL data and uploaded media.

Story Filler began as a postgraduate Professional Software Development course project. I delivered the application, a working local Kubernetes demo and the supporting coursework within the course deadline.

After the course, I adapted the application for long-term public demonstration with low hosting costs and less infrastructure to maintain. The managed deployment accepts slower initial access and limited configured capacity for a small, infrequently visited application.

Architecture. I separated compute, data and media, moving public delivery to managed hosting while retaining the local infrastructure work as part of the project.

Delivery. The implementation separates Terraform configuration from application image releases, with independent frontend and backend pipelines.

Verification. I used AI assistance to investigate release and security findings, then checked the changes through regression tests, independent review, scanning and deployed API reads.

Rona and the Moon in the Story Filler application, showing a story paragraph, a vocabulary bank and audio controls.
The public application · Rona and the Moon · Story view captured 28 September 2026.

02 / Architecture

The workload stayed small.
The operating model changed.

Local environments expose networking, storage and workload lifecycle directly. Managed hosting reduces the infrastructure operated for the public application, while configuration, dependencies and data remain project responsibilities.

The public deployment

Compute, relational data and media have separate homes.

Deployment verified
Client Browser React application
HTML / JS
Static hosting GitHub Pages
HTTPS API
Application runtime Cloud Run Django · Gunicorn · WhiteNoise
→ Neon PostgreSQL Queries over TLS
Public media
Object storage Google Cloud Storage Images and pronunciation audio

The browser requests assets from Pages, API responses from Cloud Run and public media from GCS. Django accesses Neon and integrates with GCS for media management.

The orchestration lab

An earlier implementation retained in Infra/.

Course-era implementation
Client Browser
Traffic entry Ingress Frontend and API path routing
↓ Routes to application Services
Service + Deployment Frontend Nginx container
Service + Deployment Backend Django + media PVC
Service + StatefulSet PostgreSQL Database PVC
  • Backend → PostgreSQL Service
  • Migration & admin Jobs → database
  • Secret references → workloads
  • Debug Pods → network / database checks

The historical manifests describe single-replica workloads. The September review inspected these manifests and the current frontend's /story-filler/ path support. See the configuration review notes.

The development feedback loop

One browser origin; service names inside the network.

Configuration checked
Client Browser localhost
Shared entry point Nginx :80 Pages, API, admin and media
↓ Routes to frontend and backend
Frontend Vite :5173 Source mount + HMR
Backend Django :8000 Source + media mounts
Database PostgreSQL Named data volume
  • Django → PostgreSQL as db
  • Nginx → Vite WebSocket for HMR
  • Browser → same-origin /api/
  • Database readiness → migrate → start

Compose configuration parsing passed. The production-style variant uses built frontend assets and Gunicorn. See the configuration review notes.

Configuration reviewed 27 September 2026. See the verification methods and deployment results.

03 / Decisions & trade-offs

Choose what to operate.
Match it to the workload.

The goal changed after the course: from completing a local submission to keeping a small application publicly accessible. I chose managed services to reduce hosting costs and infrastructure maintenance, accepting slower initial access and limited configured capacity. The decisions below explain where those trade-offs appear in the implementation.

a.

Match compute to a modest workload

The Cloud Run revision template sets a minimum of zero and maximum of one instance, with 1 vCPU and 512 MiB per instance. Static frontend hosting removes a continuously running frontend service. The aim is a manageable footprint for a personal application.

Accepted cost Cold starts and a low capacity ceiling. Capacity and operating cost depend on the workload.
b.

Keep state outside replaceable compute

Neon holds relational data; GCS holds uploaded media. Releasing a backend image does not require moving those files or database records between containers.

Accepted cost More provider and access-control boundaries. Schema compatibility, backups and restoration remain application responsibilities.
c.

Separate infrastructure from application releases

Terraform declares Artifact Registry, the runtime service account, Cloud Run and public invocation. CI selects the commit-tagged image; Terraform ignores changes to that image field.

Accepted cost CI manages image selection; Terraform manages the declared service resources. Neon, media/state buckets and CI identity are deployment prerequisites.

This September 2026 retrospective connects the migration account to decisions visible in the implementation.

04 / Local platform practice

Practice networking,
lifecycle and persistence.

The existing local configurations show service networking, workload lifecycle and persistence directly. Selected source files below make those choices inspectable.

Docker Compose

Networking & iteration

A shared Nginx origin connects the browser to Vite and Django while the backend reaches the database by service name.

  • Source mounts and HMR for the development loop.
  • Separate data and media volumes.
  • Readiness check, migration and startup order.
  • Same-origin API and frontend path corrections in the review.

Kubernetes

Lifecycle & state

Different resources express the needs of serving traffic, storing data and performing finite operational tasks.

  • Deployments and Services for applications.
  • PostgreSQL StatefulSet and persistent storage.
  • Separate migration and administrator Jobs.
  • Secret references and diagnostic Pods.
Earlier demo Host-run Django / React. Compose starts only PostgreSQL. A simpler full-text story contract.
Maintained application Separate story list/detail responses, paragraphs, word-bank links and media.
Different environments Each stage serves a distinct purpose: prototype, local platform practice and public demonstration.

These files preserve the earlier local implementation. The September review examined their configuration and connection to the maintained application. Read the review notes.

05 / Delivery

A release should have
an observable result.

The backend pipeline connects a source revision to a tested image, security checks, a Cloud Run update and read-only checks of the deployed API. Frontend delivery is independent. Both releases require fresh source-code and Git-history secret scans.

Step 1 Test PostgreSQL + regression checks
Step 2 Build Multi-stage, non-root image
Step 3 Scan Vulnerability + secret gates
Step 4 Deploy Commit-tagged image
Step 5 Verify Live public API reads

A historical release / September 2026

The scanner blocked the first attempt.

Trivy found 12 fixable HIGH findings: ten in Pillow and two in libraries bundled with pip. Image publication and deployment stopped. The fix upgraded Pillow to 12.3 and removed unnecessary installer tooling from the final runtime image after dependency checks. Build tooling stayed in the builder.

The next release passed the same scanning policy, deployed and passed the public API smoke check.

The November review made source findings blocking and extended the image gate to HIGH/CRITICAL findings including those without a vendor fix. Five required checks protect merges. Documentation-only pull requests keep source, dependency and unit checks, while avoiding an unnecessary image rebuild and recovery exercise. See the verified results.

06 / Delivery history

A development record,
including the failed runs.

Story Filler continues the work from the original private repository, jothep/maori-story-fill. Its cleaned Git history is preserved in the new project. The earlier Actions records stay with their source repository.

Original commits
185
October 2025–May 2026
Historical workflow runs
198
126 succeeded · 72 failed
Workflow breakdown, collection notes & downloads

Legacy repository snapshot · 28 September 2026 · 132 distinct source commits across the retained Actions records.

Retained workflow results from the original private repository
Workflow family Runs Success Failure
Earlier backend CI 41 21 20
Earlier frontend CI 48 22 26
Cloud Run delivery 18 6 12
GitHub Pages delivery 37 28 9
CodeQL analysis 50 45 5
Git history credential scan 3 3 0
Initial combined pipeline 1 1 0
Total 198 126 72

The authenticated GitHub Actions API returned 198 completed run records; each reported one attempt. The table counts completed CI, security-scan and delivery workflow runs.

The cleaned migration baseline contains 189 commits: the original 185 commits preserved once, plus four September publication-preparation commits.

Download the Actions snapshot (JSON) · Download the Git/source snapshot (JSON) · Read the collection notes

The new public repository independently passed frontend and backend delivery and history scanning on 28 September 2026. Its release records are separate from the earlier workflow totals.

Verified release from the new repository

Current project · story-filler

New repository. Separately verified delivery.

Migration snapshot 1713b97 contains 190 commits, including the preserved 189-commit baseline. The move retained the existing Cloud Run service and runtime configuration; the backend release changed only the image.

The public run records below document the new repository's release. Test results, deployment details and browser checks are collected in Evidence & verification.

Source published · The new repository and its run records are publicly accessible, confirmed on 28 September 2026. Read the public verification summary (JSON).

Delivery verified

07 / AI-assisted engineering

Use AI to investigate.
Use evidence to decide.

AI assisted the September–November reviews, implementation and documentation. The useful outcome is an inspectable chain from a problem to a verified change.

  1. Frame the work

    I set the direction: preserve the existing project, prioritize valuable improvements, keep credentials out of public history, and distinguish implementation from deployment evidence.

  2. Investigate and implement with assistance

    The work used AI to trace configuration, dependencies and source findings. The November changes replaced affected frontend tooling, separated build and runtime dependencies, removed unused SQLite, and added regressions for the security fixes. Suggestions were checked against source, runtime behavior and pipeline results.

  3. Keep the verification visible

    Failed checks and successful reruns remain inspectable. The November release passed 522 automated tests and seven recovery scenarios before publication, with independent review and fresh scans. Public API and page checks then confirmed the deployed result.

In my July essay, Stop Asking What AI Can Do. Ask What You Can Verify, I explain why domain knowledge and human judgment matter when using AI. The release investigation above offers a concrete engineering example of that approach.

08 / Evidence & verification

Checks behind
the release.

The 3 November 2026 review connected individual findings to code changes, regression tests and the published release. The source-security review, dependency audits and complete application-image reports returned no known findings in this dated check.

Story Filler security review and release verification, 3 November 2026
Area Result What was checked
Source security 11 alerts fixed Each CodeQL finding was assessed for its actual input and execution path. Fixes hardened demo responses, request logging and the local Pages check. Full release scans passed; all 11 original alerts were marked fixed without dismissals or query exclusions.
Regression coverage 522 tests passed 40 Django tests against PostgreSQL, 172 maintenance tests, four demo checks, 229 lint/type contracts, 71 frontend component tests and six real Pages HTTP tests. Seven additional backup and recovery scenarios passed in isolated PostgreSQL and media resources.
Dependencies & images Scans passed Separate runtime, development and build locks were audited with exact package coverage. The runtime image contains no SQLite. Complete reports covered 68 backend and 71 frontend image packages, with zero vulnerabilities reported at all severities; full and production npm audits also passed.
Published application Verified Reviewed source 6497dce reached Cloud Run revision 00034-frg and GitHub Pages. The backend serves 100% of service traffic; public story, detail and configuration reads passed, along with frontend page and asset requests.
Recurring checks First run passed Weekly maintenance repeats source, Git-history, dependency and image checks. Its first manual execution passed. New findings enter a reviewed change; the scanning workflow does not deploy or apply upgrades automatically.

Published run records: backend release, frontend release and first maintenance run.

Local configuration review method

Static inspection covered the historical Kubernetes manifests: single-replica workloads, PostgreSQL probes and path-based Ingress routing. Current frontend source supports /story-filler/. Compose configurations passed parsing.

This September configuration review also checked Terraform formatting and validation; state inspection listed four declared resources. A runtime reproduction of the historical Kubernetes lab would additionally check host-mount and media-volume permissions.

Historical release records · September 2026

The 28 September repository-migration release passed 11 backend tests using SQLite and local media, six offline smoke-check tests and six frontend tests. Source 1713b97 reached revision 00028-gdm; read-only API checks and browser checks of the story list, detail and image passed. The November record above uses the expanded test suite and PostgreSQL.

The public historical verification summary records the blocked image release, remediation and subsequent checks. Original Actions logs remain in the private repository; the delivery history above includes publicly accessible aggregate downloads and separate new-repository runs.

Read technical documentation on GitHub

09 / Published writing

The reasoning behind
the implementation.

These two Medium articles record the project's earlier architecture and delivery choices. Start with the migration rationale, then the pipeline design; use the current case study and verification record to follow what changed.

How the published articles relate to today's project

The articles retain their original titles and describe the project at publication. It is now named story-filler, with a new public repository and application URL. The migration article describes S3-compatible storage; the current media backend is GCS.

Later reviews strengthened delivery checks and updated the runtime. Terraform continues to manage the declared GCP resources; source security, image scanning and regression checks now protect publication. See the dated checks and release results.

Explore selected writing, including my approach to AI verification

Back to selected work