docs(mission): add PulseCast plan, data findings and access notes
release-please / release-please (push) Failing after 3s

This commit is contained in:
Noel Sabia committed 2026-11-13 20:14:32 +01:00
1 parent 48ffb5ba08
commit 8afb767585
11 files changed
+1227

No files matched your search

+5
View File
@@ -1,3 +1,8 @@
# The media mention export is ~210 MB and exceeds common hosting limits. # The media mention export is ~210 MB and exceeds common hosting limits.
# It is provided in the local workspace and referenced by the OKF bundle. # It is provided in the local workspace and referenced by the OKF bundle.
Stadt Heilbronn/*.json Stadt Heilbronn/*.json
# Cluster credentials — never commit
fch26-onemanarmy-sa-kubeconfig.yaml
*kubeconfig*.yaml
*.kubeconfig
+1
View File
@@ -12,6 +12,7 @@ All six partner challenges from the Future City Hackathon 2026 are captured as a
| `knowledge/data/` | Dataset concepts for the supplied CSV and JSON files. | | `knowledge/data/` | Dataset concepts for the supplied CSV and JSON files. |
| `knowledge/organizers/` | One concept per partner organization. | | `knowledge/organizers/` | One concept per partner organization. |
| `knowledge/log.md` | Chronological update log. | | `knowledge/log.md` | Chronological update log. |
| `mission/` | Working plan for the Schwarz Digits Pulse of the City challenge: product thesis, data findings, architecture, 24-hour plan, demo script, open decisions. |
The original briefs, decks, and data files stay in their organizer folders at the repository root. The OKF concepts link to them instead of copying them. The 210 MB Stadt Heilbronn media export is kept locally and git-ignored because it exceeds common hosting limits. The original briefs, decks, and data files stay in their organizer folders at the repository root. The OKF concepts link to them instead of copying them. The 210 MB Stadt Heilbronn media export is kept locally and git-ignored because it exceeds common hosting limits.
+91
View File
@@ -0,0 +1,91 @@
# Mission — PulseCast
**Status: DRAFT.** The product choice below is a recommendation, not a settled decision. Open decisions are in [questions.md](questions.md). Do not treat this as final until Q1 is answered.
## The task, in one paragraph
Schwarz Digits' **Pulse of the City** challenge asks for a production-ready application on STACKIT/SKE that turns privacy-preserving PAX-counter footfall data from Heilbronn's inner city into decisions about advertising, store locations, or staffing. Bonus points for **Vue.js + Go + Onyx**. Judged on idea, implementation, reliability, documentation, and storytelling. We have from **Saturday 07:00** to **Sunday 13:00**; the preselection demo is **Sunday 10:00**.
## The bet
Most teams will ship a footfall dashboard. **We ship a staffing copilot**: a store manager sees the next 7 days of footfall, gets a shift recommendation, and can test weather/event scenarios live. The map and charts support the decision; they are not the product.
Why this bet:
- **The data supports it.** 8 sensors, 5 months of multi-sensor data, 15-minute intervals, clear daily and weekly peaks. See [data.md](data.md).
- **The challenge supports it.** "Dynamic Staffing" is one of the three named use cases; predictions are the explicit stretch goal.
- **The judging supports it.** Originality is a stated criterion and "generic dashboard" is the thing to avoid. A decision workflow is distinctive.
- **The demo supports it.** One scenario change visibly changes a recommendation on every phone.
## Hero user and decision
- **User:** store manager at an inner-city retailer (e.g. near Stadtgalerie / Kaiserstraße).
- **Decision:** "How many staff per hour next week, and when?"
- **Output:** 7-day hourly forecast, recommended shift plan, coverage/cost, what-if scenarios.
- **Secondary:** city operations / PreZero can use the same pulse map. They are not the hero.
## The 3-minute demo
1. Open on a phone. Pick "Stadtgalerie."
2. See the week: Saturday peak, weather context, recommended shifts.
3. Change scenario: **"sunny Saturday + Christmas market."** Forecast rises; recommendation adds staff; cost/coverage updates.
4. The same change lands on the jury's phones via the live view. *"You just saw the decision a manager would make."*
5. Close on the honest limitation: 8 sensors, 5 months, estimates not counts — and the path to more.
## Scope
**Must (P0):**
- Deployed on SKE, public HTTPS URL, health checks, README.
- 8-sensor map with measured points (no fake city-wide heatmap).
- 7-day hourly forecast per sensor, weather-aware, validated against a baseline.
- Staffing recommendation view with transparent assumptions.
- Live scenario broadcast (SSE) to stage + phones.
- Mobile-responsive; works on a phone without installing anything.
**Should (P1):**
- Audience "join the pulse" QR view + poll.
- Onyx components; Chart.js with the Onyx theme.
- Sensor health/battery view; data-coverage panel.
- Custom domain via Cloudflare Tunnel.
**Cut (P2):**
- Store-location recommender; city-wide heatmap claims.
- Live Python inference service; deep learning; LLM chat.
- Auth/SSO/multi-tenant; Postgres/Kafka/Flink; CI/CD beyond a Makefile.
- Real-time sensor ingestion — we only have a CSV.
- Custom domain if it blocks deployment.
## Definition of done
- A judge can open the URL on a phone, pick a store, see next week, change a scenario, and see a recommendation change in under 2 seconds.
- The app survives a cold start, a refresh, and 120 concurrent SSE clients.
- The README explains what it does, how it works, how to run/deploy it, and where it breaks.
- The demo can run from a laptop + 3 phones, with a recorded fallback.
- No PII, no MAC addresses, no fake precision.
## Success
- **Primary:** win the Schwarz Digits preselection on Sunday 10:00.
- **Stretch:** final pitch at 14:00.
- **Evidence:** deployed URL, reliable demo, clear decision, honest limitations, documentation.
## Non-negotiables
- No coding after **Sunday 06:00**. No cluster changes after **Sunday 06:00**.
- No demo dependency on venue Wi-Fi: phones use mobile data; the laptop has a local fallback.
- No generic dashboard. Every screen answers "what should I do?"
- No claim that 8 sensors measure the whole city.
## Folder map
| File | Purpose |
|---|---|
| [README.md](README.md) | Mission, product thesis, scope, definition of done. |
| [data.md](data.md) | What the actual PAX data contains, what it supports, and the baseline model results. |
| [architecture.md](architecture.md) | Smallest architecture that survives the stage, deployment plan, failure modes. |
| [plan.md](plan.md) | 24-hour timeline, gates, agent workstreams, risks. |
| [demo.md](demo.md) | Pitch script, live demo choreography, fallback ladder, Q&A bank. |
| [questions.md](questions.md) | Open decisions with recommendations; answer these first. |
+214
View File
@@ -0,0 +1,214 @@
# Architecture — namespace-only, three services, Cloudflare Tunnel
## Recommendation in one line
Run **three namespace-scoped Deployments** — Nuxt SSR web, Go API/SSE, Python FastAPI ML — behind a **Cloudflare Tunnel**, with the model and data baked into images, no database, no Ingress, no cert-manager, no external-dns, and a cached fallback in Go if FastAPI is unavailable.
## What the kubeconfig actually allows
Verified against `fch26-onemanarmy-sa-kubeconfig.yaml` on 2026-11-13:
| Can create | Cannot create |
|---|---|
| Deployments, Services, ConfigMaps, Secrets, ServiceAccounts, Pods, PVCs | **Ingress**, **Jobs**, **CronJobs**, NetworkPolicies, Roles, RoleBindings |
- No cert-manager CRDs, no Gateway API, no `IngressClass` visibility.
- No ResourceQuota or LimitRange — three small pods fit.
- Public image pull works; a non-root `nginx-unprivileged` pod ran successfully.
- **Exposure:** Cloudflare Tunnel, because Ingress is not permitted.
- **Batch:** build-time, because Jobs/CronJobs are not permitted.
- **TLS:** terminated at Cloudflare; no cert-manager needed.
- **DNS:** Cloudflare Tunnel public hostnames; no external-dns needed.
## System
```text
┌────────────────────────────────────────────┐
phones / laptop │ Nuxt 4 SSR (Onyx, Chart.js, MapLibre) │
pulse.noelsabia │ Node server, server-rendered shell │
└───────────────┬────────────────────────────┘
│ HTTPS
┌───────────────▼────────────────────────────┐
│ Cloudflare edge + Tunnel │
│ pulse.noelsabia.dev -> web:3000 │
│ api.pulse.noelsabia.dev -> api:8080 │
└───────────────┬────────────────────────────┘
│ outbound from cloudflared pod
┌───────────────▼────────────────────────────┐
│ cloudflared Deployment (namespace-scoped) │
└───────┬───────────────────────┬────────────┘
│ │
┌─────────────▼────────────┐ ┌───────▼────────────────┐
│ Go API + SSE + cache │ │ Nuxt SSR server │
│ scenario state (1 pod) │ │ calls api:8080 │
└─────────────┬────────────┘ └────────────────────────┘
│ internal HTTP
┌─────────────▼────────────┐
│ FastAPI ML service │
│ /predict /simulate │
│ /healthz /meta │
└──────────────────────────┘
```
**Build-time:**
```text
CSV ──► Python batch (pandas, sklearn) ──► model + JSON forecasts
│
┌─────────────────────────┴──────────────────┐
│ baked into ml image │
│ copied into Go image as fallback JSON │
└────────────────────────────────────────────┘
```
## Why this shape
| Choice | Why | Cost |
|---|---|---|
| Nuxt SSR | Fast first paint on phones; you know Nuxt; Onyx SSR was tested and works. | A Node Deployment; hydration and SSE care. |
| Go API | Bonus stack; small binary; SSE fan-out; scenario state; cache. | One more service to deploy. |
| FastAPI | Your requested Python service; model inference and scenario queries. | Third Deployment; must not be a single point of failure. |
| Cloudflare Tunnel | The only exposure path the namespace allows; free TLS; no Ingress, no cert-manager. | One `cloudflared` pod and a tunnel token. |
| Baked model/data | No PVC, no database, no runtime data fetch. | Rebuild image to update data/model. Fine for 24 h. |
| Cached fallback in Go | If FastAPI is down, the core screens still work from precomputed JSON. | Slight duplication of data. Worth it. |
| One API replica | SSE state is in memory; 120 clients fit. | No HA. Documented. |
## Stack
- **Frontend:** Nuxt 4.6.4, `ssr: true`, `@sit-onyx/nuxt` 1.2.0, `sit-onyx` 1.22.0, `@sit-onyx/chartjs-plugin` 1.0.1, Chart.js, MapLibre GL JS (static basemap fallback).
- **Backend:** Go 1.27+, `net/http`; `chi` optional. SSE hub, scenario state, cache, health/ready.
- **ML:** Python 3.12, pandas, scikit-learn (`HistGradientBoostingRegressor`), FastAPI/Uvicorn. Horizons: 15 min, 1 h, 48 h, 7 d.
- **Registry:** Gitea at `git.noelsabia.dev`, Docker Registry v2, Let's Encrypt certificate. `imagePullSecret` in the namespace. Public Docker Hub pull also works, so `cloudflare/cloudflared` can be used directly.
- **K8s:** three Deployments + `cloudflared`, four Services, ConfigMaps/Secrets, no PVC, no CRDs, no cluster-scoped resources.
- **TLS/DNS:** Cloudflare Tunnel public hostnames. No cert-manager, no external-dns, no Ingress.
## Cloudflare Tunnel setup
1. Create a tunnel in the Cloudflare dashboard (Zero Trust → Networks → Tunnels).
2. Add two public hostnames:
- `pulse.noelsabia.dev` → `http://web:3000`
- `api.pulse.noelsabia.dev` → `http://api:8080`
(If the tunnel UI supports path routing, `pulse.noelsabia.dev/api` → `http://api:8080` is also possible; verify. Two hostnames are the reliable default.)
3. Store the tunnel token as a Secret:
```bash
kubectl -n fch26-onemanarmy create secret generic cloudflared \
--from-literal=TUNNEL_TOKEN='<token>'
```
4. Deploy `cloudflare/cloudflared:latest` with `tunnel --no-autoupdate run --token $(TUNNEL_TOKEN)`.
5. Verify `https://pulse.noelsabia.dev` and `https://api.pulse.noelsabia.dev/api/healthz`.
6. Test SSE through Cloudflare; heartbeat every 15 s. If buffering appears, fall back to polling.
**CORS:** if you use two hostnames, Go must allow `Origin: https://pulse.noelsabia.dev` and the `Authorization` header for `/control`. The browser uses `https://api.pulse.noelsabia.dev` as the API base. If you use path routing, same-origin and no CORS.
## Registry
```bash
docker login git.noelsabia.dev -u <user>
docker tag <image> git.noelsabia.dev/<owner>/<package>:<tag>
docker push git.noelsabia.dev/<owner>/<package>:<tag>
kubectl -n fch26-onemanarmy create secret docker-registry gitea-regcred \
--docker-server=git.noelsabia.dev \
--docker-username=<user> \
--docker-password=<read-only-package-token>
```
Reference `gitea-regcred` in each Deployment or the default ServiceAccount. Verify with a hello-world before building the real images. Public Docker Hub pull works as a fallback for `cloudflared`.
## Quotas and Pod Security
- No ResourceQuota or LimitRange was visible; three small pods fit.
- Still set requests/limits: web 100m/256Mi, api 100m/128Mi, ml 200m/512Mi, cloudflared 50m/64Mi.
- Run as non-root; drop all capabilities; `allowPrivilegeEscalation: false`; read-only root filesystem with an `emptyDir` at `/tmp`.
- The namespace has no explicit PSA labels; a non-root `nginx-unprivileged` pod ran. Design for restricted anyway.
- No NetworkPolicy permission; assume default allow. Test web → api and api → ml after deployment. If a default-deny policy blocks traffic, escalate; you cannot create NetworkPolicies.
## API contract
### Go API
```text
GET /api/healthz -> 200 {"ok":true}
GET /api/readyz -> 200 if data loaded
GET /api/meta -> data/model versions, coverage, metrics
GET /api/sensors -> [{id,name,lat,lon,mean,p95,battery}]
GET /api/series?sensor=&from=&to= -> [{t,v}]
GET /api/forecast?sensor=&horizon=15m|1h|48h|7d&scenario= -> [{t,v,lo,hi}]
GET /api/staffing?sensor=&scenario=&standard= -> {hours:[...],summary:{...}}
POST /api/scenario -> 202 {version, scenario}
GET /api/stream -> text/event-stream; events: scenario, pulse
```
- `scenario` enum: `base`, `sunny-saturday-market`, `rainy-saturday`, `weekday-event`; `standard`: `relaxed|standard|premium`.
- Go never computes the model. It calls FastAPI or serves the cached JSON.
- Every response carries `data_version` and `model_version`.
- SSE: `event: scenario\ndata: {...}\n\n`, heartbeat 15 s, `retry: 3000`.
- **Plan generation:** `GET /api/staffing` returns a complete next-week plan in under 2 seconds; the heuristic is deterministic and cached by `sensor|scenario|standard`.
### FastAPI ML service
```text
GET /healthz -> 200
GET /readyz -> 200 if model loaded
GET /meta -> model version, metrics, training window
POST /predict -> {sensor, horizon, scenario, weather} -> forecast
POST /simulate -> {scenario} -> forecasts for all sensors/horizons
```
- Go calls `/simulate` on a scenario change; caches by `scenario|standard`.
- If FastAPI times out (> 1.5 s) or is unhealthy, Go serves the cached JSON and marks the UI "cached forecast."
- The batch job is build-time; there is no Job/CronJob permission. A production path can use a CronJob in a less restricted namespace; document it, do not depend on it.
## Horizon semantics
| Horizon | Use | Data reality |
|---|---|---|
| 15 min | "Now" / replay pulse | One-step nowcast; needs a live/replay clock. |
| 1 h | "Now" / short operational | 4 steps; useful for immediate staffing. |
| 48 h | Plan | Day-ahead; weather-sensitive. |
| 7 d | Plan | Weekly shift plan; the hero. |
The CSV is static. Without a live feed, 15 min/1 h are replay/nowcast features, not live sensor data. Label them accordingly.
## Failure modes
| Failure | Detection | Fallback |
|---|---|---|
| No SKE access | No kubeconfig by Sat 09:00 | Escalate to contact; build locally; manifests ready. |
| Gitea pull fails | `ImagePullBackOff` | Check `gitea-regcred`, DNS, NetworkPolicy; public Docker Hub pull works as fallback. |
| Cloudflare Tunnel down | URL 502 / no tunnel | Restart `cloudflared`; use a temporary `kubectl port-forward` for the demo? No — use a backup tunnel or local fallback. |
| SSE buffered | No events on phone | Poll `/api/scenario` every 5 s; keep UI. |
| FastAPI down | `/readyz` fails | Go serves cached JSON; banner "cached forecast." |
| Nuxt SSR down | 502 on `/` | Restart pod; local fallback; recorded video. |
| No Jobs/CronJobs | Batch cannot run in-cluster | Build-time pipeline; document production path. |
| No NetworkPolicy permission | Cannot fix a default-deny | Test early; escalate to the platform. |
| Venue network | Phones cannot load | Mobile data; laptop local build; video. |
| Single API pod restarts | Brief 502 | Probes, small image, `Recreate`; SSE clients reconnect. |
## Security and privacy
- No PII, no MAC addresses, no geolocation permission; audience view uses a random session ID.
- `/control` uses **basic auth** (Go middleware) or a token; public dashboard and `/live` stay open. No SSO.
- All images run as non-root. No privileged containers.
- Secrets: `gitea-regcred`, `cloudflared` token, control credentials. Never in git.
- Same-origin or explicit CORS; no third-party trackers; bundle fonts/assets.
- UI states the data limitation: "estimated devices, not people; 8 sensors; 5 months."
- **Cluster credential:** the provided kubeconfig is a secret. It is git-ignored and chmod 600. Rotate the token after the event; it was shared in chat.
## Degradation ladder
1. **Full:** Nuxt SSR + Go + FastAPI + `cloudflared`.
2. **Two services:** Nuxt SPA served by Go + FastAPI; drop SSR if resources/time are tight.
3. **One service:** Go serves SPA, API, SSE and cached forecasts; Python is build-time only.
4. **No tunnel:** temporary `kubectl port-forward` for local verification only; not a public demo.
5. **No SKE:** local kind + recorded demo; escalate; do not pretend it meets the requirement.
## Open decisions
1. Q1: **settled** — staffing copilot.
2. SSR: **settled** — yes.
3. Replay vs static for 15 min/1 h — default: replay P1, static P0.
4. Paper: **settled** — hackathon deliverable, 4–5 pages, AI draft + human verification.
5. Herdr: **settled** — four workstreams/worktrees.
6. Basic auth scope: `/control` only (default) vs whole app (would hurt the 120-phone demo).
7. Weather: use Open-Meteo/holidays (default) or only the provided CSV. See paper/data implications.
+98
View File
@@ -0,0 +1,98 @@
# Data findings — PAX counters, Heilbronn
This is based on the actual challenge download, not the brief. Downloaded 2026-11-13 from the Schwarz Digits download link with the published password. The file is not committed to this repo; keep it in `data/raw/` and add that folder to `.gitignore`, or reuse the cache copy.
## File
| Item | Value |
|---|---|
| File | `data-1794095549194.csv` |
| Size | 18.49 MB, 192,464 rows |
| Columns | `time` (UTC ISO-8601), `sensor_id`, `name`, `longitude`, `latitude`, `type`, `value` |
| Types | `densityData` (96,232 rows), `batteryData` (96,232 rows) |
| Time range | 2025-10-16 21:17 UTC → 2026-11-07 23:51 UTC |
| Sensors | 12 device IDs; **8 usable locations** (see below) |
| Cadence | ~15 minutes (median 15.3 min; some sensors 30 min) |
## What is actually in it
- **8 usable sensors**, all in a **~580 m × 280 m cluster** around Hagenbuchersee, Neckarufer, Stadtgalerie, Marahaus and Götzenturm. This is an inner-city micro-area, not a city-wide network.
- **5 months of multi-sensor data**: 2026-06-12 → 2026-11-07. The named sensors start then; the reason is not documented. The one sensor `density-01` has 13 months of history, but it is a single location and is not enough for annual seasonality.
- **3 sensors must be excluded:** `maker-fair` (73 readings, located in Hannover), `niklas-01` (8 readings, outside the inner city), `hn-bollwerksturm-01` (5 readings).
- **`density-01` has two device IDs** (`863f75b0` and `f8c19730`) at the same location, 2025-10-16 → 2026-? and 2026-? → 2026-11-07. Merge them as one logical sensor for analysis; keep the device ID for battery/health.
- **Battery data** exists for every density reading. Useful for a sensor-health panel, not for forecasting.
## Sensor profile (multi-sensor period, 2026-06-12 → 2026-11-07)
`value` is the mean of 15-minute density readings. Higher = more devices detected.
| Sensor | Readings | Mean | Median | p95 | Max | Max daily gap |
|---|---:|---:|---:|---:|---:|---:|
| `hn-stadtgalerie-01` | 8,982 | 21.1 | 8.4 | 67.2 | 137.2 | 6 days |
| `hn-neckarufer-01` | 9,527 | 19.2 | 11.9 | 61.6 | 255.5 | 5 days |
| `hn-hagenbuchersee-02` | 10,099 | 19.3 | 11.2 | 64.4 | 200.9 | 4 days |
| `hn-marahaus-01` | 9,254 | 13.7 | 9.1 | 38.5 | 194.6 | 6 days |
| `hn-hagenbuchersee-01` | 12,345 | 13.0 | 6.3 | 49.7 | 292.6 | 4 days |
| `hn-goetzentuem-01` | 9,952 | 11.1 | 8.4 | 29.4 | 210.7 | 5 days |
| `hn-soleo-01` | 10,327 | 10.6 | 8.4 | 28.0 | 111.3 | 4 days |
| `density-01` | 12,670 | 9.9 | 7.7 | 28.0 | 63.0 | 35 days (over its longer history) |
Across the multi-sensor period the weighted mean is ~14.4. Over the full file the distribution is right-skewed: median 7.7, p95 46.9, p99 78.4, max 292.6 — most readings are low, a few hours are very busy.
## Patterns that matter for the product
**Hourly mean (local time, all 8 sensors):**
| Hour | 00 | 03 | 06 | 09 | 12 | 15 | 17 | 18 | 19 | 20 | 21 | 23 |
|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
| Mean | 9.7 | 2.4 | 3.1 | 8.0 | 17.2 | 18.8 | 24.5 | 28.4 | **31.5** | 31.3 | 28.6 | 16.8 |
- The inner city peaks **18:00–21:00 local**, with the top at 19:00. Morning is quiet.
- **Saturday is the busiest day** (mean 19.1), then Friday (16.3). Sunday is quieter (11.4) than Monday (11.9).
- The three busiest locations are **Stadtgalerie, Neckarufer and Hagenbuchersee-02**. That is a retail/leisure cluster, which fits the staffing story.
- Weather is a real signal: the quick model below improves by ~20% when temperature/rain/cloud/wind are added.
## What the data does **not** support
- **A city-wide heatmap.** Eight points across 580 m are not a city-wide measurement. An interpolated surface is an estimate; label it as such. A "pulse map" with measured points plus a clearly marked interpolation is honest.
- **A store-location recommender.** Eight sensors cannot rank commercial zones across Heilbronn. This would be a vision slide, not a feature.
- **A census of people.** PAX counters detect discoverable Bluetooth devices. Device penetration is unknown. The values are an **index of estimated devices**, not a count of people. Show a calibration assumption (e.g. "if 40% of visitors carry a discoverable device, multiply by 2.5") rather than pretending the index is exact.
- **Annual seasonality.** The 8-sensor network only covers June–November. Do not claim a full-year model. The one long sensor can illustrate a year, but not the network.
## Quick forecasting baseline
A deliberately small, reproducible baseline — not a tuned model. Hourly target = mean of 15-minute readings. Train on 2026-06-12 → 2026-10-10; test on the last 28 days (2026-10-10 → 2026-11-07). Global model across sensors, `HistGradientBoostingRegressor`, features: hour, weekday, month, weekend, lags 24/48/168, rolling means, sensor ID. Weather from Open-Meteo (historical, Heilbronn).
| Model | MAE | WAPE | R² |
|---|---:|---:|---:|
| Seasonal naive (same hour last week) | 5.40 | 44.7% | 0.462 |
| Day-ahead, no weather | 4.20 | 34.8% | 0.678 |
| Day-ahead, + temperature/rain | **3.36** | **27.8%** | **0.779** |
| 7-day-ahead, no weather | 4.37 | 36.2% | 0.672 |
**The honest read:** temperature + rain cuts day-ahead error by ~20% versus the no-weather model, and ~38% versus seasonal naive. Adding cloud/wind did not improve the short test. That is a credible differentiator, not a breakthrough. The test period is 4 weeks, weather is observed rather than forecast, and events are not modeled. Do not claim more than this.
**Why this matters for the product:** the forecast is good enough to drive a staffing recommendation, not good enough to promise exact headcounts. Show the uncertainty band and the baseline comparison. Judges reward understanding, not decimal places.
## Recommended pipeline
1. Parse CSV as UTC; convert to `Europe/Berlin` for features; handle DST explicitly.
2. Merge `density-01` device IDs into one logical sensor.
3. Exclude `maker-fair`, `niklas-01`, `hn-bollwerksturm-01`.
4. Aggregate to hourly means per sensor; keep 15-minute data for the drill-down view.
5. Join historical/forecast weather from Open-Meteo; join Baden-Württemberg holidays.
6. Train the global model; validate on a time-based holdout; export `forecasts.json`, `metrics.json`, `sensors.json`.
7. Bake the JSON into the Go binary (or serve from a volume). No runtime Python dependency.
8. Show data coverage and model metrics in the app's "About the data" panel.
## Open data questions for the mentors
1. What is the unit of `densityData` — devices per 15-minute interval, concurrent devices, or something else?
2. Where exactly are the sensors mounted, and what is their catchment area?
3. What device penetration should we assume, and is there a correction factor?
4. Why do some sensors have 4–6 day gaps? Maintenance, power, LoRaWAN coverage?
5. Is there an event log (markets, festivals, holidays) for the period?
6. Are there more sensors or a longer multi-sensor history available?
7. How often is the dataset refreshed? Is there a live API, or only this CSV?
Ask these early. The answers change the UI copy, not the build.
+129
View File
@@ -0,0 +1,129 @@
# Demo and pitch
## The one-sentence story
**"A store manager knows the weather forecast and the staff roster. She does not know how many people will walk past next Saturday. We turn five months of anonymized footfall into next week's shift plan — and you can change the scenario on your own phone."**
## Preselection vs final
| | Preselection (Sun 10:00) | Final (Sun 14:00) |
|---|---|---|
| Audience | Schwarz Digits challenge provider | Broader jury |
| Goal | Advance | Win |
| Focus | Decision, working demo, understanding | Story, vision, implementation |
| Length | Assume 5 min + questions (confirm with the organizer) | 8 min pitch + 8 min Q&A |
| Demo | Live, 3 screens | Same demo, tighter |
Rehearse the 5-minute version first. The 8-minute version is the same story with more context and vision.
## 8-minute pitch structure
| Time | Slide / beat | What you say |
|---:|---|---|
| 0:00–0:30 | Hook | "It's Friday. A store manager on Kaiserstraße has 12 staff and a sunny Saturday forecast. Should she schedule 8 people or 14? Today she guesses. We built the answer." |
| 0:30–1:15 | Problem | Raw counts are not decisions. Weather, events, and time of day change the crowd. A generic dashboard shows history; it does not tell her what to do. |
| 1:15–4:15 | **Demo** | Phone: pick Stadtgalerie. Week view: Saturday peak. Staffing plan: recommended shifts, coverage, cost. Change scenario: sunny Saturday + Christmas market. Forecast rises; plan changes. The jury's phones update. |
| 4:15–5:15 | How it works | 8 sensors, 15-minute data, 5 months. Weather fusion. Global model; time-based validation; MAE 3.36 vs 5.40 seasonal naive; WAPE 27.8%. Go + Nuxt + Onyx on SKE. No PII. |
| 5:15–6:00 | Honest limits | 8 sensors, 580 m, 5 months, devices not people, observed weather not forecast, no event log. What we would do with more data. |
| 6:00–7:30 | Vision | Add POS data, event calendars, forecast weather, more sensors. Multi-store staffing API. City operations view. Start with one store, one decision. |
| 7:30–8:00 | Close | "PulseCast: from footfall to shifts. The demo is live at `<URL>` — open it now." |
## Demo choreography
**Cast:** presenter (story), driver (clicks), timekeeper, fallback (video).
**Devices:** presenter phone, backup phone, laptop, big screen. QR code on the slide and on a printed card.
**Before the demo:**
- [ ] Reset scenario to `base`; verify the URL on mobile data.
- [ ] Warm the page; open the three tabs: `/`, `/live`, `/stage`.
- [ ] Disable notifications, auto-updates, and sleep.
- [ ] Charge all devices; bring a power bank and a hotspot.
- [ ] Download the backup video to the laptop and phone.
- [ ] Print the QR code; test it with a phone camera.
- [ ] Confirm the projector resolution and browser zoom.
**During the demo:**
1. Start on the phone, not the laptop. "This is what the manager sees."
2. Narrate the decision, not the UI: "Saturday at 19:00 is the peak. The plan adds two people from 16:00."
3. One scenario change only. "Let's make Saturday sunny and add the Christmas market." Pause. "Watch the recommendation."
4. Look up at the audience. "If you open `<URL>/live`, you see the same change. You are the manager now."
5. Stop on the recommendation screen. Do not scroll. Do not open a new feature.
**After the demo:** leave the app on `/stage` with the recommendation visible during Q&A.
## The jury-phones moment
**Purpose:** make the jury feel the decision, not just see a chart. It is a storytelling device, not a data source.
**What they see:** a mobile page with the same scenario, the forecast delta, and a one-tap poll: "Would you add staff?" The big screen shows the room's split vs the model's recommendation.
**What it is not:** geolocation tracking, MAC sniffing, or a fake sensor. Say that explicitly if asked.
**Fallback:** if the venue network or QR flow fails, skip it and say: "The live view is optional; the decision is the product." Do not debug it on stage.
## Fallback ladder
1. Live app on the jury's phones.
2. Live app on the presenter's phone.
3. Live app on the laptop, projected.
4. Recorded 90-second video.
5. Screenshots in the deck.
Never debug on stage. If the app is down, switch to the video and keep the story.
## Q&A bank
**"What is the unit? Is it people?"**
> It is an index of estimated devices detected by PAX counters, not a census. We do not know device penetration, so we show it as an estimate and expose the assumption. The decision layer works on relative peaks, which are robust even if the absolute count is uncertain.
**"Why only 8 sensors? Is this city-wide?"**
> No. Eight sensors in a 580 m inner-city cluster. That is exactly why we picked staffing for one store, not a city-wide heatmap or a store-location recommender. We would rather be honest and useful than impressive and wrong.
**"How do you validate the model?"**
> Time-based holdout: train June–October, test the last 28 days. Day-ahead MAE 3.36 with weather vs 4.20 without vs 5.40 seasonal naive. WAPE 27.8% vs 44.7%. We show the baseline and the limitations in the app.
**"Is the weather real or synthetic?"**
> Historical observed weather for training and validation. The what-if scenarios are counterfactual inputs to the model, clearly labeled as scenarios. In production we would use the forecast API and show a confidence band.
**"Why Nuxt + Go + Onyx?"**
> Vue and Go are the Digits stack; Onyx is the design system. Nuxt gives us a fast, typed frontend build; Go gives us one small binary with SSE and static serving. One deployable, fewer failure modes. The Onyx Nuxt module is official.
**"Is this production-ready?"**
> For a hackathon: deployed on SKE, HTTPS, health checks, resource limits, seeded data, no secrets in the repo, documented limitations. Not production-ready for multi-tenant auth, HA, or live ingestion — and we say so.
**"Why not store locations or advertising?"**
> The data supports staffing: 8 locations, 5 months, clear daily/weekly peaks. Store-location ranking needs city-wide granularity we do not have. Advertising is a secondary view; staffing is the decision with a measurable cost and schedule.
**"What would you do with more time/data?"**
> Add POS conversion data, event calendars, forecast weather, more sensors, and multi-store optimization. Then the same engine becomes a staffing API for a retail group.
**"How did you use AI agents?"**
> Agents owned isolated workstreams — data/ML, Go API, Nuxt UI, infra — against a written API contract. The human owned decisions, integration, deployment, and the demo. Same as a small engineering team, with faster iteration and more review.
**"What broke?"**
> Be specific and honest: a data gap, a timezone bug, an SSE buffering issue, a model leakage mistake. Judges reward understanding more than a perfect story.
## Do not say
- "City-wide heatmap." It is 8 sensors in 580 m.
- "Real-time sensor data." It is a historical CSV, with a live scenario layer.
- "Predicts people." It estimates devices.
- "Production-grade" without the caveat.
- "AI" as a feature. The model is a means to a decision.
- "We built a platform." You built a product for one decision.
## Slides (max 8)
1. Title + one-line promise + URL/QR.
2. The decision: "8 or 14 staff on Saturday?"
3. The data reality: 8 sensors, 5 months, 15 min, 580 m.
4. Demo (live; one slide as backup).
5. How it works: pipeline, model, weather, metrics.
6. The product: forecast → staffing plan → scenario.
7. Honest limits + what we would do next.
8. Vision + close + URL/QR.
Keep text large. One idea per slide. The demo is the slide.
+90
View File
@@ -0,0 +1,90 @@
# Access verification — what the kubeconfig allows
Verified on 2026-11-13 ~20:15 against `fch26-onemanarmy-sa-kubeconfig.yaml`.
## Verdict
The kubeconfig is **enough to deploy workloads**, but **not enough to expose them with an Ingress** and **not enough to run Jobs/CronJobs**.
**Use Cloudflare Tunnel for HTTPS/domain. Use a build-time batch for ML. Do not plan on Ingress, cert-manager, external-dns or Jobs.**
## Permissions
| Can create | Cannot create |
|---|---|
| Deployments, Services, ConfigMaps, Secrets, ServiceAccounts, Pods, PVCs | **Ingress**, **Jobs**, **CronJobs**, NetworkPolicies, Roles, RoleBindings |
Also:
- No cert-manager CRDs, no Gateway API, no `IngressClass` visibility.
- No ResourceQuota or LimitRange — three small pods fit.
- No explicit Pod Security Admission labels; a non-root `nginx-unprivileged` pod ran successfully.
- Public image pull works (Docker Hub, 2.8 s).
- The namespace is `fch26-onemanarmy`; context `fch26-onemanarmy-sa-context`.
## What this means for the architecture
| Need | Path |
|---|---|
| Public HTTPS URL | **Cloudflare Tunnel** (`cloudflared` Deployment), not Ingress. |
| TLS certificate | Cloudflare edge; no cert-manager. |
| DNS | Cloudflare Tunnel public hostnames; no external-dns. |
| Batch training | Build-time pipeline; no Job/CronJob in this namespace. |
| Registry | Gitea `git.noelsabia.dev` with `imagePullSecret`; public Docker Hub also works. |
| Pod-to-pod traffic | Test web → api → ml after deployment. You cannot create NetworkPolicies; if a default-deny exists, escalate. |
## Security — act on this
The kubeconfig contains a service account bearer token and was shared in chat. Treat it as compromised.
- Token expiry: **2026-11-23 19:49 CET** — valid through the hackathon.
- The file is **git-ignored** and **chmod 600**.
- **Rotate/revoke the token after the event**, or ask the organizers for a new kubeconfig if you want to rotate before Sunday.
- Never paste the token into chat, a commit, a slide, or a screenshot.
- Create a separate **read-only** Gitea package token for the cluster pull; do not reuse your admin token.
## Remaining blockers / next actions
1. **Gitea image pull**
- Create a read-only package token.
- `docker login git.noelsabia.dev`, push a hello-world.
- Create `gitea-regcred` in `fch26-onemanarmy`.
- Deploy the hello-world and verify it runs.
2. **Cloudflare Tunnel**
- Create a tunnel in Cloudflare Zero Trust.
- Add public hostnames:
- `pulse.noelsabia.dev` → `http://web:3000`
- `api.pulse.noelsabia.dev` → `http://api:8080`
- Create the `cloudflared` Secret with the tunnel token.
- Deploy `cloudflare/cloudflared` and verify both URLs over HTTPS.
3. **Connectivity**
- Deploy web/api/ml with ClusterIP Services.
- Test api → ml and web → api from inside the namespace.
- If a default-deny NetworkPolicy blocks traffic, escalate; you cannot create one.
4. **SSE**
- Test `EventSource` through Cloudflare with the 15 s heartbeat.
- If buffered, use the frontend polling fallback.
5. **Product/data clarifications**
- Q6: use only the provided CSV, or allow Open-Meteo weather/holidays?
- Q7: basic auth on `/control` only, or the whole app?
- Q9: paper format (Markdown → PDF is fine).
## Mentor questions — minimum
1. What Pod Security Admission level applies to `fch26-onemanarmy`?
2. Is there a default-deny NetworkPolicy in the namespace?
3. Is outbound 443 to Cloudflare allowed for `cloudflared`? (Image pull works, so egress exists.)
4. Is there any restriction on running `cloudflared` or using Cloudflare Tunnel?
5. If we need a runtime batch job, can the namespace be granted `create jobs` / `create cronjobs`? If not, build-time is fine.
## Done when
- [ ] Gitea hello-world runs in the namespace.
- [ ] `https://pulse.noelsabia.dev` and `https://api.pulse.noelsabia.dev/api/healthz` respond.
- [ ] web → api → ml connectivity verified.
- [ ] SSE event arrives on a phone through Cloudflare.
- [ ] Token rotation plan is noted for after the event.
+116
View File
@@ -0,0 +1,116 @@
# MVP decision — what exactly are we building?
Status: **Q1 settled on 2026-11-13.** Build the staffing copilot. Everything else is downstream.
## Decision (2026-11-13)
- **Hero:** staffing copilot for a Lidl/Kaufland store manager near Stadtgalerie / Kaiserstraße.
- **Output:** a usable next-week shift plan, generated in a few seconds, with visible assumptions.
- **Reusable core:** forecast + scenario engine.
- **Live layer:** SSE for scenario changes; frontend polling for data/model updates.
- **Paper:** hackathon deliverable about the core.
## The trap
"Pulse of the City" sounds like a dashboard. A dashboard is exactly the generic solution the preselection criteria penalize: it shows data, but it does not change a decision. The MVP must be a **decision**, with the map and charts as supporting evidence.
The technical stack is not the differentiator. Nuxt SSR, Go, FastAPI, SSE and SKE are delivery mechanisms. The judges will remember one thing: **what decision does this change?**
## Options
| Option | Data fit | User value | Demo strength | Originality | 24h effort | Reusable / paper |
|---|---|---|---|---|---|---|
| **Staffing copilot** | High | High | High | High | Medium-high | High |
| Ad placement planner | Medium | Medium | High | Medium | Medium | High |
| Store-location recommender | Low | Low | Medium | Low | Medium | Low |
| City pulse dashboard | Medium | Low | Medium | Low | Low | Medium |
| Dynamic waste routing | Low | Medium | Medium | Medium | High | Medium |
**Scores explained:**
- **Staffing:** the data's strongest signal is time-of-day and weekday. The decision is a shift plan: concrete, recurring, and measurable. The challenge explicitly names staffing. The demo changes a plan, not just a map.
- **Advertising:** the data has only eight fixed locations. Ranking eight points is a coarse spatial decision, and the demo collapses into a map — the generic dashboard trap. No ad inventory, cost or reach data.
- **Store location:** needs city-wide spatial granularity. Eight sensors in 580 m cannot rank commercial zones across Heilbronn. This would be dishonest.
- **City pulse dashboard:** useful context, no decision. It is a supporting view, not the product.
- **Dynamic waste routing:** requires waste-container and route data, plus optimization. Out of scope for this challenge and this dataset.
## Recommendation: PulseCast
**One sentence:** *PulseCast turns 15-minute footfall data into a 7-day staffing plan for an inner-city store, with a live what-if simulator.*
**Primary user:** a store manager at a Heilbronn inner-city retailer — Lidl, Kaufland, or an independent store near Stadtgalerie / Kaiserstraße.
**Job to be done:** *"Tell me how many people will walk past next week, and how many staff I need, hour by hour."*
**Decision:** the weekly shift plan. Not "explore the data." Not "look at a heatmap." A plan the manager can accept, edit or reject.
**Why this wins the challenge:**
- It uses the data where it is strongest: time-of-day, weekday, weather and location.
- It maps directly to "Dynamic Staffing," one of the three named use cases.
- It produces a concrete artifact — a shift plan — that a judge can imagine using on Monday.
- It is original relative to the dashboards other teams will build.
- The forecasting engine is reusable for advertising and city operations later; the staffing app is the first consumer.
## The MVP in five screens
1. **Now** — pulse map of the 8 sensors, current/replay reading, weather, last update. This is the "Pulse of the City" context.
2. **Forecast** — 48-hour and 7-day forecast per location, with uncertainty band, weather context and baseline comparison.
3. **Plan** — the hero screen: recommended staff per hour, shift blocks, coverage score, over/understaffed hours, estimated labor cost, comparison to a flat schedule.
4. **Simulate** — presenter changes weather / event / service standard; forecast and plan update; all phones stay in sync via SSE.
5. **About** — data coverage, model metrics, assumptions, privacy, limitations.
The hero screen is **Plan**. Everything else supports it.
**Plan generation requirement:** one click on "Generate next week" returns a shift plan in **under 2 seconds**. The plan is a table of 2–4 hour shift blocks per day, staff counts per hour, coverage score, cost, and a comparison to a flat schedule. The manager can edit the assumptions and regenerate. Export as CSV/print view. Not a drag-and-drop optimizer; a usable plan, fast.
## The decision logic — transparent, not magic
The ML predicts **footfall**. A separate, explainable heuristic turns footfall into staff:
```text
forecast footfall per hour
→ visitors per staff per hour (service standard)
→ required staff = ceil(footfall / standard × safety factor)
→ minimum staff, shift length, opening hours
→ shift blocks + coverage score + cost
```
The assumptions are visible and adjustable:
- visitors per staff per hour
- labor cost per hour
- minimum staff
- shift length
- safety factor
We do **not** have POS, sales, queue or labor-cost data. The app must say that. It predicts footfall; the staffing plan is decision support with explicit assumptions. That is honest and still useful. Do not claim a precise ROI.
## What is explicitly out of the MVP
- Ad-placement UI and store-location scoring. The forecast API can support them later.
- City-wide heatmap claims. The map shows measured points and a clearly labeled interpolation, not a city-wide surface.
- Real-time sensor ingestion. The dataset is a CSV; there is no live feed.
- Auth/SSO, multi-tenant roles, HA, Kafka, Postgres, deep learning, LLM chat.
## Decision record for Q1
### Q1.1 — Primary user
**Answered:** Lidl/Kaufland store manager near Stadtgalerie / Kaiserstraße.
### Q1.2 — Decision output and assumptions
**Answered:** a usable next-week shift plan, generated in a few seconds, with visible assumptions. Not a "busiest hours" dashboard, not an ad ranking. No fake ROI.
### Q1.3 — Reusable core vs app
**Answered:** forecast + scenario engine is the reusable core and the paper subject; the staffing app is the first consumer.
## Consequences of the other answers
- **SSR:** Nuxt SSR needs a Node deployment; Go API is a second deployment; FastAPI is a third. That is fine, but plan three pods, a Cloudflare Tunnel, and a load test. Onyx SSR was tested and works.
- **FastAPI + four horizons:** 15 min and 1 h are nowcasts; 48 h and 7 d are planning. The 15 min/1 h horizons need a live clock — the CSV has no live feed. Use a replay clock (P1) or keep them as model metrics. Base forecasts must be cached in Go so a FastAPI failure does not blank the app.
- **120 users:** Go SSE handles 120 easily; Nuxt SSR must handle 120 page loads; FastAPI is called once per scenario, not once per user. Test 120 concurrent SSE clients with k6.
- **Auth:** public read-only app; basic auth on `/control` only. The audience view stays frictionless.
- **Paper:** the paper is a hackathon deliverable. Target a 4–5 page technical report about the core; AI drafts, human verifies every number and citation. The demo takes priority over LaTeX polish.
+124
View File
@@ -0,0 +1,124 @@
# Paper — what "halfway good" means and how to get it fast
Status: **hackathon deliverable**, due Sunday 13:00. Target a 4–5 page technical report (PDF). AI can write the prose; you verify every number and citation. The demo takes priority over LaTeX polish.
## What makes it halfway good
A paper is not good because it is long. It is good when a reader can answer these six questions:
1. **What problem, for whom?** A store manager needs a next-week shift plan from footfall data.
2. **What data, with what limits?** 8 sensors, 5 months, 15-minute cadence, 580 m cluster, devices not people.
3. **What method, and why?** Global gradient-boosted model, weather fusion, multi-horizon forecasting, transparent staffing heuristic.
4. **Did it work?** A time-based holdout, a seasonal-naive baseline, MAE/WAPE/R², an ablation. Real numbers.
5. **Does it run?** Nuxt SSR + Go + FastAPI on SKE, Cloudflare Tunnel, SSE, cached fallback, 120-user load test.
6. **What does it not do?** No city-wide heatmap, no POS/labor data, no live sensors, no annual seasonality, no causal claims.
If those six are clear, it is halfway good. Novelty is a bonus, not a requirement for a hackathon technical report.
## Structure (4–5 pages)
| Section | Length | Content |
|---|---:|---|
| Abstract | 150–200 words | Problem, data, method, headline result, deployment. |
| 1. Introduction | 0.5 page | The decision gap; why a dashboard is not enough; three contributions. |
| 2. Data | 0.75 page | PAX counters, 8 sensors, 5 months, 15 min, 580 m, coverage/gaps, device-penetration bias, privacy. |
| 3. Method | 1 page | Preprocessing, features, global HistGB, weather fusion, horizons, time-based split, staffing heuristic. |
| 4. System | 0.75 page | Nuxt SSR, Go API/SSE, FastAPI, Cloudflare Tunnel, SKE namespace-only, build-time batch, cached fallback. |
| 5. Evaluation | 1 page | Baseline comparison, weather ablation, per-sensor errors, plan latency, 120-client load test. |
| 6. Discussion & limitations | 0.5 page | 8 sensors, 5 months, observed weather, no POS/labor data, single replica, no auth. |
| 7. Related work | 0.25 page | PAX counters/privacy, pedestrian forecasting, gradient boosting, smart-city dashboards. |
| 8. Conclusion & future work | 0.25 page | More sensors, POS/event data, multi-store, city operations. |
| References | 8–12 | Real, verifiable sources only. |
## Required figures and tables
**Figures (4–5):**
1. Sensor map of the 580 m cluster (8 points; label the sensor names).
2. Hourly and weekday footfall profile (the "pulse").
3. Forecast vs actual for one sensor over the 28-day test (with uncertainty band).
4. Architecture diagram (three services + Cloudflare Tunnel + SKE).
5. The staffing plan screen (or a table if the screenshot is weak).
**Tables (3–4):**
1. Data coverage per sensor: readings, mean, p95, max, max gap.
2. Model comparison: seasonal naive vs no-weather vs weather, MAE/WAPE/R².
3. Ablation: weather on/off; per-sensor MAE.
4. System metrics: plan generation latency, 120 SSE clients, image sizes, deployment time.
## Facts and numbers to use (do not invent)
- **Data:** 192,464 rows total; 96,232 density readings; 12 device IDs; **8 usable sensors**; 3 excluded test sensors.
- **Window:** 2026-06-12 → 2026-11-07 for the 8-sensor network (~5 months); one sensor has 13 months.
- **Cadence:** ~15 minutes (median 15.3); gaps up to 6 days per sensor; 351 days covered overall.
- **Spatial:** ~584 m × 284 m cluster; not city-wide.
- **Values:** 0–292.6; multi-sensor mean ~14.4; median 7.7; p95 46.9; p99 78.4.
- **Pattern:** peak 18:00–21:00 local, top 19:00; Saturday busiest (mean 19.1).
- **Model:** global HistGB; train 2026-06-12 → 2026-10-10; test last 28 days.
- **Baseline:** seasonal naive MAE 5.40, WAPE 44.7%, R² 0.462.
- **No weather:** MAE 4.20, WAPE 34.8%, R² 0.678.
- **With temperature/rain:** MAE **3.36**, WAPE **27.8%**, R² **0.779**.
- **7-day:** MAE 4.37, WAPE 36.2%, R² 0.672.
- **Caveat:** weather is observed, not forecast; no event data; 4-week test; values are device estimates, not people.
- **System:** 3 Deployments + `cloudflared`; no Ingress, no cert-manager, no Jobs; build-time batch; Cloudflare Tunnel; SSE + polling fallback; Go cache; plan < 2 s.
- **Load test:** fill in after k6; do not claim a number you did not measure.
## AI writing prompt
Copy this into the agent that writes the paper. Replace the bracketed values with the real ones after the load test.
```text
You are writing a 4–5 page technical report for a hackathon. Use ONLY the facts in
mission/data.md, mission/mvp.md, mission/architecture.md and the facts below. Do not
invent citations, numbers, datasets, or results. If a fact is missing, write
"[TODO: verify]" instead of guessing.
Topic: PulseCast — a staffing copilot for an inner-city store, built on 8 PAX
counters in Heilbronn. The paper documents the forecasting/scenario core, not the UI.
Facts:
- 192,464 CSV rows; 96,232 density readings; 12 device IDs; 8 usable sensors; 3 excluded.
- 8-sensor window 2026-06-12 to 2026-11-07; ~15-min cadence; 580 m cluster.
- Values are estimated devices, not people; device penetration unknown.
- Peak 18:00–21:00 local; Saturday busiest.
- Global HistGradientBoostingRegressor; time-based holdout of 28 days.
- Seasonal naive: MAE 5.40, WAPE 44.7%, R2 0.462.
- No weather: MAE 4.20, WAPE 34.8%, R2 0.678.
- With temperature/rain: MAE 3.36, WAPE 27.8%, R2 0.779.
- 7-day: MAE 4.37, WAPE 36.2%, R2 0.672.
- Weather is observed, not forecast; no event data; 4-week test.
- System: Nuxt 4 SSR + Go API/SSE + FastAPI on STACKIT SKE, namespace-only,
Cloudflare Tunnel, no Ingress/cert-manager/Jobs, build-time batch, cached fallback.
- Staffing plan generated in under 2 seconds from a transparent heuristic with
configurable assumptions (visitors per staff per hour, labor cost, shift length,
minimum staff, safety factor). No POS/sales/labor data.
- Load test: [TODO: k6 result] concurrent SSE clients; [TODO: p95 latency].
Write Markdown with the sections: Abstract, Introduction, Data, Method, System,
Evaluation, Discussion and Limitations, Related Work, Conclusion, References.
Include 4 figure placeholders and 3 table placeholders with captions. Use past tense,
first-person plural, precise numbers, and an explicit limitations paragraph. Cite only
real sources you are confident exist; otherwise write "[CITATION TODO]".
```
## Verification checklist before submission
- [ ] Every number matches `mission/data.md` or a measured result.
- [ ] The baseline table is present; the model is compared to seasonal naive, not only to itself.
- [ ] Weather is described as observed, not forecast.
- [ ] The 8-sensor/5-month/580 m limitation is explicit.
- [ ] "Devices, not people" appears at least once.
- [ ] No claim of live sensor data; replay/nowcast is labeled.
- [ ] No fake citations; every reference is real and relevant.
- [ ] The system section matches the actual deployment (Cloudflare Tunnel, no Ingress, no Jobs).
- [ ] The staffing plan is described as decision support with assumptions, not an optimizer with proven ROI.
- [ ] Repo link, data access note, privacy statement, author/acknowledgment.
- [ ] PDF renders; figures are legible; tables fit.
- [ ] 4–5 pages, not 12.
## Schedule
- **Saturday:** agent drafts from the docs; you review the numbers and references; generate figures from the real data.
- **Sunday 07:00–09:00:** finalize the PDF, check the checklist, submit with the deck and code.
- **Do not** let LaTeX or citation hunting delay the demo. A 4-page honest report beats an 8-page invented one.
+167
View File
@@ -0,0 +1,167 @@
# Plan — Saturday 07:00 to Sunday 13:00
## The real clock
| Time | What | Hard? |
|---|---|---|
| Fri 13 Nov, evening | SKE access, data, repo skeleton, decisions | **Yes — do this today** |
| Sat 14 Nov, 07:00 | Build starts | — |
| Sat 10:00 | **Gate 1:** public HTTPS hello-world on SKE | Yes |
| Sat 13:00 | **Gate 2:** data pipeline + API contract + app shell | Soft |
| Sat 18:00 | **Gate 3:** end-to-end core on SKE, 3 phones | Yes |
| Sat 23:00 | **Feature freeze** | Yes |
| Sun 15 Nov, 06:00 | **Deploy freeze** | Yes |
| Sun 07:00–09:00 | Rehearse, record fallback, pack | Yes |
| Sun 10:00 | Preselection demo | Yes |
| Sun 13:00 | Submit presentation + code | Yes |
| Sun 14:00 | Final pitch (if selected) | Stretch |
You said "24 hours from 07:00." The actual submission deadline is **30 hours later**, but only ~24 of those are usable build time. Use the extra 6 hours for rehearsal and submission, not features.
## Friday evening (today) — 2–3 hours, not 6
- [x] Request SKE access (expected today; namespace-only).
- [x] Namespace access verified: no Ingress, no Jobs/CronJobs, no cert-manager, no quota. Use Cloudflare Tunnel and build-time batch. See [friday-blockers.md](friday-blockers.md).
- [ ] Create a Gitea package token; push a hello-world to `git.noelsabia.dev`; create `gitea-regcred`; verify the cluster pulls it.
- [ ] Download the PAX CSV (done; see [data.md](data.md)); keep it out of git.
- [ ] Decide Q1 (hero use case) and the Q1.1–Q1.3 follow-ups in [mvp.md](mvp.md).
- [ ] Create the app repo/folder skeleton: `api/`, `web/`, `ml/`, `deploy/`, `Makefile`, `README.md`.
- [ ] Verify Nuxt SSR + Onyx build (done; see `friday-blockers.md`). Do not design the UI yet.
- [ ] Sleep. Tomorrow is the long day.
## Saturday
| Time | Human | Data/ML agent | Go agent | Nuxt agent | Infra/QA agent |
|---|---|---|---|---|---|
| 07:00–08:00 | Stand-up, confirm namespace, assign | Verify CSV, write parser | API skeleton, health | Nuxt SSR shell | Namespace smoke test, Gitea pull |
| 08:00–10:00 | Unblock, deploy hello-world | Hourly aggregation, features | Contract endpoints | Layout, mock data | Cloudflare Tunnel, **Gate 1** |
| 10:00–13:00 | Integrate, review | Baseline model, FastAPI skeleton | Sensors/series/forecast | Map + time series | Build/push all three images |
| 13:00–16:00 | **Gate 2**, integrate | Weather join, scenario grid | Staffing endpoint, SSE, cache | Staffing view, scenario controls | Deploy web/api/ml, smoke test |
| 16:00–19:00 | Test on phones, cut | FastAPI fallback test, model card | Load test 120 SSE | Mobile polish, live view | SSE through Tunnel, **Gate 3** |
| 19:00–22:00 | Demo rehearsal #1 | Fix data/API edge cases | Fix API/SSE bugs | Fix UI bugs, empty states | Load test, rollback drill |
| 22:00–23:00 | Freeze, tag, deploy | Freeze model/JSON | Freeze binary | Freeze build | Freeze manifests |
| 23:00–23:30 | **Feature freeze.** Write down what is cut. | — | — | — | — |
| 23:30–04:30 | Sleep (yes, really) | — | — | — | — |
If Gate 1 slips past 10:00, stop feature work and fix deployment. If it slips past 12:00, escalate to the mentors and switch to the fallback. Do not build a beautiful app that is not on SKE.
## Sunday
| Time | What |
|---|---|
| 04:30–06:00 | Final verification. Fix only a demo blocker; re-deploy the frozen image; verify health. |
| 06:00–07:00 | **Deploy freeze.** No cluster changes. |
| 07:00–08:30 | Rehearse the 5-minute preselection demo and the 8-minute final; record a backup video. |
| 08:30–09:00 | Pack: laptop, charger, 3 phones, hotspot, QR slide, backup video, USB stick. |
| 10:00 | Preselection. Demo. Explain. Do not debug on stage. |
| 13:00 | Submit presentation + code. |
| 14:00 | Final pitch if selected. |
## Workstreams and agent contracts
The human owns decisions, integration, deployment, and the demo. Agents own code in isolated folders. Do not let agents deploy to SKE without review.
### 1. Human — architect / integrator / presenter
- Owns `mission/`, `deploy/`, the final demo, and every merge.
- Writes the API contract before agents start.
- Runs the 10:00 / 13:00 / 18:00 / 23:00 checkpoints.
- Cuts scope without debate when a gate slips.
- Does not write frontend CSS at 02:00.
### 2. Data/ML agent — `ml/`
- Owns `ml/`, `data/` (git-ignored raw), generated JSON, the FastAPI service.
- Delivers: batch pipeline (`make data`), `sensors.json`, `series.json`, `forecasts.json`, `metrics.json`, `model_card.md`, FastAPI `/predict` and `/simulate` with `/healthz` and `/readyz`.
- Must not touch `web/` or `api/` code.
- Definition of done: reproducible batch run; time-based validation; baseline comparison; no leakage; FastAPI starts with the baked model; JSON schema matches the contract; Go cache fallback tested.
- Prompt: *"Read mission/README.md, mission/data.md and mission/architecture.md. Build the batch pipeline and FastAPI service. Do not tune for more than 2 hours. Report MAE/WAPE vs seasonal naive and the exact JSON/API schema."*
### 3. Go agent — `api/`
- Owns `api/`.
- Delivers: health/ready, sensors, series, forecast, staffing, scenario POST, SSE stream, FastAPI client, cached fallback, tests for the SSE hub and handlers.
- Must not touch `web/` or `ml/`.
- Definition of done: `go test ./...`; runs with the generated JSON; works when FastAPI is down; 120 concurrent SSE clients; graceful shutdown.
- Prompt: *"Read mission/architecture.md. Implement the API contract exactly. Use the JSON fixtures in `api/testdata/`. Cache FastAPI responses and fall back to baked JSON. Do not add a database, a framework, or auth beyond the control token."*
### 4. Nuxt agent — `web/`
- Owns `web/`.
- Delivers: app shell, pulse map, time-series chart, forecast + staffing view, scenario controls, `/live` mobile view, `/stage` big-screen view, `/control` token page, empty/error states.
- Must not touch `api/` or `ml/`.
- Definition of done: builds with `nuxt build` (SSR); works with mock JSON before the API exists; responsive at 390 px and 1440 px; no console errors; browser-only map/chart wrappers; Onyx components where sensible.
- Prompt: *"Read mission/README.md and mission/architecture.md. Build the screens against the mock data in `web/mock/`. Use `@sit-onyx/nuxt` with SSR. Wrap MapLibre and SSE in client-only components. Keep the map dependency replaceable with a static image."*
### 5. Infra/QA agent — `deploy/`
- Owns `deploy/`, Dockerfiles, Makefile, smoke tests, load test.
- Delivers: multi-stage Dockerfiles for web/api/ml, namespace-only k8s manifests, Cloudflare Tunnel Deployment, imagePullSecret, PSA-compliant securityContext, `make deploy`, `make smoke`, `make load`.
- Must not change app logic or install cluster-scoped resources.
- Definition of done: a fresh namespace deploys all three images plus `cloudflared`; HTTPS works; `/api/healthz` and FastAPI `/healthz` pass; 120 SSE clients for 5 minutes; rollback documented.
- Prompt: *"Read mission/architecture.md and mission/friday-blockers.md. Produce namespace-only manifests, a Cloudflare Tunnel Deployment, and a smoke test. Do not install cert-manager, external-dns, an ingress controller, Jobs/CronJobs or any CRD. Use the Gitea registry."*
## Integration cadence
Every checkpoint: build, deploy, open on a phone, update the README, write down what broke.
| Checkpoint | Demoable outcome | If missing |
|---|---|---|
| Sat 10:00 | Public HTTPS hello-world | Stop features; fix deployment. |
| Sat 13:00 | Real data in API; app shell on SKE | Cut map polish; keep data + shell. |
| Sat 18:00 | Forecast + staffing + scenario on 3 phones | Cut audience view and poll. |
| Sat 23:00 | Frozen demo, 5-minute run-through | Cut to 3 screens: map, forecast, staffing. |
## Effort budget
| Area | Share | Why |
|---|---:|---|
| Frontend + SSR integration | 35% | The long pole. Map, charts, responsive, scenario UI, hydration, empty states. |
| Data/ML + FastAPI | 20% | Batch baseline is proven; FastAPI, caching and fallback add work. |
| Go API + SSE | 15% | Straightforward, but cache fallback and 120-client load testing take time. |
| Infra + deployment | 20% | Namespace-only, Gitea registry, Cloudflare Tunnel, three services, smoke tests. |
| Demo + docs | 10% | High leverage for judging; do not leave it to the last hour. |
If you are solo, cut the audience view, the poll, the custom domain, and the battery panel. Keep the map, forecast, staffing, scenario, SSE, and SKE deployment.
## Risks
| Risk | Likelihood | Impact | Mitigation |
|---|---|---|---|
| SKE access late | Medium | Blocks the requirement | Access requested, expected today; namespace smoke test; escalate Saturday 09:00; manifests ready. |
| Namespace quota too small | Medium | Three pods do not fit | Check quota first; degradation ladder: 2 pods or 1 pod. |
| Gitea pull fails | Medium | No images | Test hello-world pull; check `gitea-regcred`, DNS, NetworkPolicy; public registry fallback. |
| Cloudflare Tunnel unavailable | Medium | No public HTTPS | Check outbound 443; use a temporary local tunnel; escalate. |
| Frontend scope explodes | High | Misses freeze | Three screens only; mock data first; cut P1 at 18:00. |
| Over-engineering | High | Wastes the day | Three services maximum; no DB, no extra platform, no CI beyond build/push. |
| FastAPI is a single point of failure | Medium | Blank demo | Go caches forecasts; FastAPI optional at runtime; test the fallback. |
| Venue network fails | Medium | Demo dies | Mobile data; local build; recorded video. |
| Onyx/Nuxt SSR integration | Low | UI delay | SSR tested; wrap browser-only components; fall back to SPA. |
| Model/data leakage | Medium | Credibility | Time-based split; no future features; show baseline. |
| Single API pod restarts | Low | Brief outage | Probes, small image, `Recreate`, local fallback. |
| Agent integration conflicts | Medium | Merge pain | Four worktrees, folder ownership, API contract, human review. |
| No sleep | Medium | Bad pitch | Sleep 4–5 h; storytelling is 30% of the final score. |
## Friday-night checklist
- [x] SKE access requested (namespace-only).
- [x] Namespace access verified: no Ingress, no Jobs/CronJobs, no cert-manager, no quota. Cloudflare Tunnel is the exposure path.
- [ ] Gitea token created; hello-world pushed; `gitea-regcred` created; cluster pull verified.
- [ ] Hero use case chosen (Q1.1–Q1.3).
- [ ] Realtime meaning chosen (Q4: a + c).
- [ ] Nuxt SSR + Onyx hello-world builds (verified).
- [ ] Repo skeleton + API contract written.
- [ ] Raw CSV downloaded and git-ignored.
- [ ] Alarm set for 06:30.
## Sunday-morning checklist
- [ ] Deployed URL opens on a phone on mobile data.
- [ ] `/api/healthz`, `/api/readyz` and FastAPI `/healthz` return 200.
- [ ] Scenario change reaches the phone in under 2 seconds.
- [ ] FastAPI down test: app still serves the cached forecast.
- [ ] 120 SSE clients for 5 minutes.
- [ ] Audience QR opens `/live` without login.
- [ ] Backup video plays offline.
- [ ] Pitch deck PDF on a USB stick and in the cloud.
- [ ] Code and presentation submitted before 13:00.
+192
View File
@@ -0,0 +1,192 @@
# Open decisions
Answer these in chat; I will update the docs. Each has a recommended answer and a default. If an answer is missing by **Friday 22:00**, we build the default.
## Settled facts (no need to answer)
- **Challenge:** Schwarz Digits — Pulse of the City. The repo's remaining source material and the proposed stack both point there. If this is wrong, say so now.
- **Data:** downloaded and inspected. 8 usable sensors, 5 months of multi-sensor data, 15-minute cadence, 580 m inner-city cluster. See [data.md](data.md).
- **Baseline:** day-ahead MAE 3.36 with weather vs 5.40 seasonal naive; WAPE 27.8% vs 44.7%. Credible, not spectacular.
- **Onyx + Nuxt:** `@sit-onyx/nuxt` 1.2.0 and `@sit-onyx/chartjs-plugin` 1.0.1 exist. The integration risk is lower than expected.
- **Deadline:** preselection Sunday 10:00; submit by 13:00; final 14:00.
- **Repo:** greenfield application; only the knowledge bundle and organizer PDFs exist. No app code to preserve.
## Round 2 answers (2026-11-13)
| Q | Answer |
|---|---|
| Q1 | **Open — central discussion.** See [mvp.md](mvp.md). |
| Q2 | SKE access **requested, expected today**. **Namespace-only** — no cluster-admin. Gitea registry at `git.noelsabia.dev`. Custom domain via manual Cloudflare record. |
| Q3 | Solo, using **herdr** to coordinate many AI agents. |
| Q4 | **(a) + (c)**: live dashboard + presenter-driven what-if broadcast. No audience-as-sensors, no poll chosen. |
| Q5 | Nuxt used often in production; **no Onyx experience**; likely **SSR** for fast first render. |
| Q6 | Python service with batch updates + **FastAPI** called by Go; horizons **15 min, 1 h, 48 h, 7 d**. |
| Q7 | No auth/SSO; public multi-user; live data refresh via polling; bare-minimum CI/CD and observability; HTTPS and health checks required. |
| Q8 | **120 people** will connect; design for that. |
| Q9 | Win = fully deployed on STACKIT, usable on every phone, reusable for later use cases, and a published technical paper. |
| Q10 | User handles submission logistics. |
**New fact:** Nuxt 4.6.4 + Onyx 1.22.0 SSR was smoke-tested tonight: build and server render work (HTTP 200, Onyx button in server HTML). SSR is viable.
## Round 3 answers (2026-11-13, later)
| Q | Answer |
|---|---|
| Q1 | **Staffing copilot + SSE.** Q1 is settled. |
| Q1.1 | Lidl/Kaufland store manager. |
| Q1.2 | A usable next-week shift plan, generated in a few seconds. Not a research optimizer. |
| Q1.3 | Forecast + scenario engine is the reusable core. |
| Q2 | SSR is fine. |
| Q3 | SSE for live scenario; frontend polls for data/model updates. |
| Q4 | The paper is a **hackathon deliverable**. |
| Q5 | Four workstreams, four worktrees, one contract. |
| Q6 | Kubeconfig provided; **namespace-only verified**. See below. |
| Q7 | Basic auth is acceptable. Scope to confirm: `/control` only, or the whole app. |
| Q8 | k6 for load testing. |
| Q9 | AI may write the paper; needs a technical checklist and human verification. |
### Verified from the provided kubeconfig
- Context `fch26-onemanarmy-sa-context`, namespace `fch26-onemanarmy`.
- Service account token valid until **2026-11-23 19:49 CET** — enough for the hackathon.
- Can create: Deployments, Services, ConfigMaps, Secrets, ServiceAccounts, Pods, PVCs.
- Cannot create: **Ingress**, **Jobs**, **CronJobs**, NetworkPolicies, Roles, RoleBindings.
- No cert-manager CRDs, no Gateway API, no `IngressClass` visibility.
- No ResourceQuota or LimitRange — three small pods fit.
- Public image pull works; a non-root `nginx-unprivileged` pod ran successfully.
- **Exposure path:** Cloudflare Tunnel, not Ingress.
- **Batch path:** build-time, not a Kubernetes Job/CronJob.
- **Security:** the kubeconfig is a secret, now git-ignored and chmod 600. Rotate the token after the event; it was shared in chat.
---
## Q1 — Hero use case
**Question:** Which use case is the product? (a) dynamic staffing, (b) targeted advertising, (c) strategic store locations, (d) city operations, (e) all three.
**Why it matters:** "All three" is how you end up with a generic dashboard, which the preselection criteria explicitly penalize. The data supports staffing best: 8 locations, 5 months, clear daily/weekly peaks. Store-location ranking needs city-wide granularity we do not have.
**Recommendation:** **(a) dynamic staffing** for one inner-city store. The map and advertising view are supporting evidence, not the product. Store location is a vision slide only.
**Default:** staffing.
---
## Q2 — SKE access and domain
**Answered:** Access verified. Namespace `fch26-onemanarmy`; service account can create workloads but not Ingress, Jobs or CronJobs. No cert-manager, no external-dns, no quota. Use **Cloudflare Tunnel** for `pulse.noelsabia.dev` and `api.pulse.noelsabia.dev`, and the **Gitea registry** with an `imagePullSecret`. See [architecture.md](architecture.md) and [friday-blockers.md](friday-blockers.md).
---
## Q3 — Team, time, and agents
**Question:** Are you solo with AI agents, or are there human teammates? How many humans, what are their strengths (frontend, ML, infra, design, pitching), and how many productive hours can each give? How many agents can run in parallel, with what tooling? How much sleep are you planning?
**Why it matters:** The human is the integration bottleneck. More agents do not remove the need to review, merge, deploy, and rehearse. A 24-hour all-nighter costs you the 30% storytelling score.
**Recommendation:** 1 human + 3–4 agents maximum, each with a folder and a written contract. Sleep 4–5 hours. Feature freeze Saturday 23:00. If solo, cut the audience view, the poll, the custom domain, and the battery panel.
**Default:** solo + agents; 4 hours sleep; cut P1.
---
## Q4 — What "realtime on phones" means
**Question:** Which of these do you mean? (a) the dashboard updates live, (b) the jury's phones act as sensors, (c) the presenter changes a what-if scenario and every phone updates, (d) the audience votes/polls and the big screen reacts.
**Why it matters:** (b) is a privacy and reliability trap; it is also not the challenge. (c) is the strongest demo: it makes the jury feel the decision. (d) is a nice engagement layer but another moving part.
**Recommendation:** **(c) + (a)**, with (d) as optional P1. Never (b). The live layer must deliver the core value — a changed staffing recommendation — not just moving numbers.
**Default:** (c) + (a); (d) if time.
---
## Q5 — Frontend stack
**Question:** Nuxt + Onyx, Nuxt + custom UI, or plain Vue + Vite + Onyx? Have you used Nuxt and Onyx before? Do you want SSR or a static SPA? MapLibre or a static basemap?
**Why it matters:** The bonus says Vue.js, not Nuxt. Nuxt adds build complexity; Onyx has an official Nuxt module, so it is less risky than it looks. A live map adds a tile/network dependency; a static basemap is more reliable on stage.
**Recommendation:** **Nuxt 4 SPA (`ssr: false`) + `@sit-onyx/nuxt` + Chart.js/Onyx** if you are comfortable with Nuxt. Otherwise plain Vue + Vite + Onyx. Use MapLibre for the demo, with a static basemap fallback. Do not bet the UI on a component library you have never used.
**Default:** Nuxt SPA + Onyx; static basemap fallback.
---
## Q6 — ML shape
**Question:** Python batch training with precomputed forecasts, a Python FastAPI inference service, or a Go-only heuristic? What horizon and granularity: 7 days hourly, 48 hours 15-minute, or both? Retrain at runtime?
**Why it matters:** A Python service is a third runtime to deploy, monitor, and debug. The model is small and the data is static; batch is more production-sane and more reliable on stage. The what-if scenarios can be precomputed as a grid.
**Recommendation:** **Python batch**, global HistGB, 7-day hourly forecast, weather-aware, with a precomputed scenario grid. No runtime Python. Show metrics and a seasonal-naive baseline. If the jury asks for live inference, explain the trade-off; do not add it at 20:00.
**Default:** batch.
---
## Q7 — "Production-ready" bar
**Question:** What must production-ready include for you? Auth/SSO? Multi-user? Live data refresh? HA? CI/CD? Observability? Or is it "deployed, HTTPS, health checks, seeded data, docs"?
**Why it matters:** "Production-ready" is unbounded. In 24 hours, auth and HA would eat the demo. The judges reward understanding and reliability, not a checklist of enterprise features you cannot finish.
**Recommendation:** **SKE + HTTPS + health/ready + resource limits + seeded data + README + architecture diagram + no secrets + honest limitations.** No auth for the public dashboard; a token for `/control`; one replica, documented. Say what is not production-ready.
**Default:** as recommended.
---
## Q8 — Demo environment
**Question:** Are you on site? How many people in the room? How reliable is the Wi-Fi? Is there a projector? Are QR codes allowed? Will phones use mobile data? How much travel/setup time before 10:00?
**Why it matters:** The demo is a judged implementation criterion. A live audience view that depends on venue Wi-Fi is a single point of failure.
**Recommendation:** Design for **50–100 phones on mobile data**, one presenter, one driver, a recorded 90-second fallback, and a printed QR code. Test the QR on site. The app must work without the audience view.
**Default:** 50 phones, mobile data, backup video.
---
## Q9 — Success definition
**Question:** What does winning look like: advancing from the Schwarz Digits preselection, winning the final, building a reusable product, or learning something specific?
**Why it matters:** Preselection and final reward different things. Preselection is the gate; the final weights vision and storytelling. A reusable product would need more docs and less demo polish.
**Recommendation:** **Win the Schwarz Digits preselection**; treat the final as a stretch. Optimize every decision for the Sunday 10:00 demo, not the 14:00 stage.
**Default:** preselection.
---
## Q10 — Submission and logistics (lower priority)
**Question:** Where and how do we submit the presentation and code by 13:00? Is there a template or portal? Is the repo expected on GitHub? Do we need a PDF, a link, or both? What time do you need to leave for the venue?
**Why it matters:** A last-hour submission surprise is avoidable. This does not change the build, but it changes the Sunday checklist.
**Recommendation:** Confirm with the organizers today. Prepare a PDF deck, a public repo, and the live URL. Submit by **12:30**, not 13:00. Pack a USB stick and a charger.
**Default:** PDF + repo + live URL; submit 12:30.
---
## Answer template
Copy this into chat:
```text
Q1: staffing / advertising / store location / city / all
Q2: access status, registry, DNS zone, domain, mentor contact
Q3: humans, agent count/tooling, hours, sleep
Q4: a / b / c / d (can combine)
Q5: Nuxt / Vue / SSR / SPA / map choice, experience level
Q6: batch / FastAPI / Go, horizon, granularity
Q7: must-have list
Q8: on-site, audience size, Wi-Fi, projector, QR, mobile data
Q9: preselection / final / product / learning
Q10: submission mechanism, travel time
```