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.
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
ClientBrowser
React application
HTML / JS→
Static hostingGitHub Pages
HTTPS API→
Application runtimeCloud Run
Django · Gunicorn · WhiteNoise
→ Neon PostgreSQL
Queries over TLS
Public media→
Object storageGoogle 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.
Traffic entryIngress
Frontend and API path routing
↓ Routes to application Services
Service + DeploymentFrontend
Nginx container
Service + DeploymentBackend
Django + media PVC
Service + StatefulSetPostgreSQL
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
ClientBrowser
localhost
→
Shared entry pointNginx :80
Pages, API, admin and media
↓ Routes to frontend and backend
FrontendVite :5173
Source mount + HMR
BackendDjango :8000
Source + media mounts
DatabasePostgreSQL
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.
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.
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.
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
TestPostgreSQL + regression checks
Step 2
BuildMulti-stage, non-root image
Step 3
ScanVulnerability + secret gates
Step 4
DeployCommit-tagged image
Step 5
VerifyLive 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.
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.
AI assisted the September–November reviews, implementation and documentation. The
useful outcome is an inspectable chain from a problem to a verified change.
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.
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.
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.
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.
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.
Why a solo-maintained application moved from a Kubernetes lab to static frontend
hosting, Cloud Run and Neon. The central decision was to reduce the infrastructure
to operate while keeping compute, data and media separate.
How separate frontend and backend workflows take changes through validation, build
and deployment, with Terraform managing the declared cloud infrastructure. A small
project puts familiar enterprise delivery practices into a simpler operating
model.
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.