How this site was built

Ukraine War Live is an automated, serverless OSINT aggregator modelled on iranwarlive.com. It has no back-end server and no database in the usual sense. Everything runs on Cloudflare's edge platform, entirely within the free tiers, so the infrastructure itself costs $0 / month to run; the only real money is the domain and a Claude subscription (see section 11). This page describes the whole system in detail — enough to rebuild it.

The entire project — architecture, every line of code, the deployment, the DNS, and this write-up — was generated by Claude (Anthropic's Claude Code), with a human only steering, reviewing and approving. Source: github.com/4LaERz0GWNnuZqmnH/ukraine-war-live.

1. The shape of the system

RSS feeds (13)                                    DeepStateMap
   │                                                  │
   ▼                                                  ▼
┌────────────────────┐ ┌────────────────────┐ ┌────────────────────┐ ┌──────────────┐
│ uwl-ingest-strikes │ │ uwl-ingest-ground  │ │ uwl-ingest-frontline│ │ uwl-sitrep   │
│ Worker + Cron 2h   │ │ Worker + Cron 2h   │ │ Worker + Cron 6h   │ │ Cron 04:10   │
│ RSS → AI → dedup   │ │ RSS → AI → dedup   │ │ current + history  │ │ 1 AI call/day│
└─────────┬──────────┘ └─────────┬──────────┘ └─────────┬──────────┘ └──────┬───────┘
          └───────────────┬──────┴───────────────┬──────┴────────────────┬──┘
                          ▼                      ▼                       ▼
        ┌──────────────────────────────────────────────────────────────────┐
        │                 Cloudflare KV  (one namespace)                    │
        │  live:strikes  live:ground   archive:<pipeline>:<day> (+ index)   │
        │  dedup_store  processed:<pipeline>  promotions  frontline:geojson  │
        │  sitrep:<date>  stats:summary  status:*  runs_log                  │
        └───────────────────────────────┬──────────────────────────────────┘
                                        ▼
                    ┌──────────────────────────────────────────┐
                    │  uwl-api  (Worker, edge-cached)          │
                    │  api.ukraine.bugg.club                   │
                    │  /feed.json /api/search /archive/*       │
                    │  /frontline.json /frontline/history/*    │
                    │  /sitrep /rss.xml /status /llms.txt      │
                    └─────────────────┬────────────────────────┘
                                      ▼
                    ┌──────────────────────────────────────────┐
                    │  Cloudflare Pages — ukraine.bugg.club     │
                    │  static HTML + self-hosted MapLibre GL    │
                    └──────────────────────────────────────────┘

Five Workers, one KV namespace, one Pages project. Cron Triggers do the scheduling; there is nothing to keep running and nothing to pay for at idle.

2. The stack, and why

3. The ingestion pipeline, step by step

Two ingest Workers share one code path (shared/pipeline.ts), parameterised by a PIPELINE variable of strikes or ground. Each fires on its own cron — strikes on the hour every 2 hours, ground 30 minutes later — so they never write KV at the same time.

1. Fetch feeds. All feeds for this pipeline are fetched concurrently with Promise.allSettled. A feed that errors is recorded and skipped; it never fails the run. Cloudflare edge-caches each response for 5 minutes.
2. Parse. Workers have no XML DOM, so a small regex parser pulls title, link, publish date and a short summary from RSS and Atom items alike.
3. Age filter. Items older than 96 hours (4 days) are dropped. The rest are sorted newest-first.
4. Drop seen URLs. A hash of every link this pipeline has processed is kept in processed:<pipeline> (30-day TTL, pruned each run). The set is per pipeline: most feeds are shared, so a single set let whichever worker ran first mark every article seen and starve the other. Up to 45 unseen items proceed.
5. AI extraction. The unseen items are sent as a JSON array to Llama 3.3 70B at temperature 0.1 with a strict system prompt. The model is told to emit only a JSON array, to copy the exact source_url of the item an event came from, and to never guess coordinates. Output is capped at 20 strike events / 12 ground events per run. If that model errors (retired, overloaded, quota) the run falls back to a smaller Llama in order; the model that actually answered is recorded in the run status.
6. Validate. Every object is checked: known event type, a real http(s) URL, a valid confidence tier, coordinates inside a Ukraine + western-Russia bounding box (else nulled). Anything malformed is discarded rather than shown.
7. Geocode fallback. For events the model left without coordinates, a gazetteer resolves the place name — a hand-curated table of oblast centres, front-line towns and Russian refinery/airfield cities, backed by ~6,000 populated places from open GeoNames data (rebuilt with npm run build:gazetteer). Settlement-centroid precision, no geocoding API call.
8. Cross-run dedup. Each surviving event gets two signatures: a URL hash, and a content signature scaled to how precise the location is. A model-supplied point uses type + 0.1° grid cell + 1-hour bucket. A coarse position (gazetteer centroid or none) with a named place uses type + place slug + 3-hour bucket — so two outlets writing up the same strike on the same town collapse to one; with no place name it falls back to a normalised-headline hash. Territorial change and diplomacy use 4-hour buckets. If either signature is already in the KV key dedup_store the event is dropped. That store is pruned by age (30 days) and hard-capped at 40k keys.
9. Corroboration. When a dropped duplicate comes from a different outlet than the first report of that event, it counts as independent corroboration. At two or more outlets the original event is promoted to the High confidence tier in the live feed and the API (the raw archive line keeps whatever tier it was written with).
10. Archive. Kept events are appended as NDJSON — one JSON object per line — to archive:<pipeline>:<day>, with a matching day → count index. Each pipeline only writes its own keys, so the append is race-free; the API merges the two on read.
11. Live cache. The newest 200 events for this pipeline are written to live:strikes / live:ground. That is what the map reads.
12. Bookkeeping. A one-line run record (feeds OK/failed, items, fresh, extracted, kept, any errors) goes to status:* and a rolling runs_log.

4. Confidence tiers

Every event carries exactly one tier, which is the marker colour on the map.

5. The front-line layer

uwl-ingest-frontline runs every 6 hours. It fetches deepstatemap.live/api/history/last — a ~600 KB GeoJSON of the current control map — and keeps only the polygons whose status is occupied, plus Crimea and the pre-2022 ORDLO areas. DeepState's satirical "territories" (Karelia, Ichkeria, and so on) and the liberated/dismissed polygons are filtered out. The trimmed FeatureCollection is stored at frontline:geojson and served, heavily cached, from /frontline.json; the map draws it as a semi-transparent red fill beneath the event markers. The same worker also keeps a weekly snapshot and, the first time it runs, backfills snapshots for ~7/14/30/60/90 days ago from DeepState's public history list — that is what the map's "compare front line to <date>" control draws as a blue underlay. Front-line data is © DeepStateMap.live, CC BY-NC-SA 4.0.

6. The daily SITREP

uwl-sitrep fires once a day at 04:10 UTC. It reads the previous UTC day's archived events, sends a slimmed copy to Llama 3.3 70B with an editor prompt, and stores the result — a one-line headline plus four to seven grouped bullets — at sitrep:<date>. Reports are kept indefinitely and shown on the Daily page, newest first. It is one small model call per day, a few hundred neurons.

7. Storage model

One KV namespace holds everything:

8. The read API

uwl-api is the fifth Worker, on api.ukraine.bugg.club. It has the KV binding and serves reads; idempotent GETs are cached at the Cloudflare edge (caches.default). Its one write path is a cron (every 2 hours) that folds the raw page-view data points from Cloudflare Analytics Engine into the stats:summary KV key the About page reads. The ingest Workers have no public URL at all — the API Worker invokes them for manual runs over a service binding (Worker-to-Worker, no internet hop).

9. The frontend

Plain HTML, one CSS file, one JS file — no framework and no application build. For deployment a small esbuild + html-minifier script (npm run build:web) minifies web/ into dist/ and rewrites every asset reference to a content hash, so a redeploy can never serve a stale mix of old and new files; Pages publishes dist/. MapLibre GL is served from the site itself (web/vendor/), not a CDN; the base map is OpenFreeMap's key-less "Liberty" style. The script plots markers coloured by confidence tier and offers filters by time window, event type and confidence tier, a time scrubber that plays events forward, the front-line compare control, and toggles for the occupied area and the independent-blog markers. The map is progressive enhancement: if WebGL or the tile server is unavailable, the sidebar — counts, per-type tally, and a list of events with no mapped location — still renders. Other pages: Daily (SITREPs), Chronology (with archive search), Status, and a chrome-less /embed.html for iframes. The feed refreshes every 10 minutes client-side; the data changes every 2 hours. A _headers file sets a Content-Security-Policy and the usual hardening headers. Every page except the embed loads a tiny fire-and-forget beacon (beacon.js) that POSTs only its path to /hit; the counting is done server-side against a daily-rotating hash, with no cookies and no client-side identifiers, and the 30-day totals are shown on the About page.

10. Hosting and DNS

• ukraine.bugg.club → Cloudflare Pages custom domain (CNAME to the *.pages.dev project).
• api.ukraine.bugg.club → a Workers custom domain on the uwl-api Worker (Cloudflare manages the record and cert).
• The other four Workers publish to no hostname; they exist only as cron jobs and service-binding targets.
• A _redirects file 302s /feed.json and the other API paths from the site domain to the API Worker.

11. Cost

Everything on Cloudflare runs inside the free tiers, so infrastructure is $0. The only fixed cost is the $15/year domain (as of August 2026). A Claude subscription is the other part of the upkeep — it is what builds the site and reviews and ships every change.

12. Deployment

Each Worker is a wrangler.toml plus a src/index.ts. Secrets (the manual-run key) are set once with wrangler secret put and survive redeploys. A GitHub Actions workflow (Node 22, wrangler 4) runs a type-check, lints the frontend JS (including every inline page script), and minifies web/ into dist/, then runs wrangler deploy for each of the five Workers and wrangler pages deploy dist for the site on every push to main. Cron schedules are declared in the Worker configs and registered automatically on deploy.

13. Rebuild it yourself (with an AI agent)

The whole project was generated by an AI agent from a running conversation, and it is meant to be reproducible the same way. Hand the repository to a capable coding agent along with the file REBUILD.md, which is written for exactly that: it lists the country-specific files to edit, the pipeline mechanics to leave alone, the Cloudflare API-token scopes, the one-off KV and secret setup, and the deploy and verify steps.

Giving an agent only this page gets a faithful re-architecture but not a faithful reproduction — the extraction prompts, the feed list, the event schema and the gazetteer are data the agent would otherwise have to re-invent, and the result drifts. The repository plus REBUILD.md is the artifact; everything needed is in it except your own account credentials.

Adapting it to a different country or conflict

REBUILD.md opens with a checklist the agent is told to put to you before it writes anything — because a different theatre changes: the RSS feed list, the geocoding gazetteer, the coordinate bounding box, the admin-region polygons, the control-map / front-line source (DeepStateMap is Ukraine-only), the actor framing in the prompts, and the site branding. If you want your own project for a different war, say so at the start and the agent will walk you through those choices; if you want the Ukraine site unchanged, you answer "same" and it skips them.

14. What this approach gets wrong

• Headline-only extraction hallucinates. The model can misplace, merge, mis-time, or mis-attribute an event. Temperature 0.1, hard caps, schema validation, the "never invent URLs/coords" instruction and outlet-based tier enforcement reduce it; they do not remove it.
• Geolocation is coarse. A gazetteer centroid is a town, not a street. Events at places not in the table stay unmapped and are listed in the sidebar; markers placed from the gazetteer are ringed white and marked "(approx. location)" in their popup. Events that resolve to the same settlement (within ~1.5 km) are merged client-side into one marker carrying a count; clicking it opens a list of the individual reports. That avoids scattering markers across a city they have no street address in.
• Deduplication trades precision for fewer near-duplicates. Coarse-located events for the same place, type and 3-hour window are treated as one entry (with a corroboration count), so two genuinely separate strikes on the same town inside that window merge. A distinct model-located event in the same 0.1° cell and hour can also be dropped.
• Coverage follows the feeds. If an event is not in one of the ~13 RSS sources within 4 days, it does not exist here. Google News RSS, a big potential source, blocks Cloudflare's egress IPs, so it was dropped.
• Casualty figures are one side's announced numbers (Ukraine's or Russia's), passed through unverified — shown with who reported them and when, and never added into a headline total.
• The front line lags. DeepStateMap updates a few times a day and this site re-pulls every 6 hours, so the red area can be up to several hours stale. The comparison snapshots are the nearest available DeepState revision to each target date, not that exact date.

15. Credits & licence

• Front-line polygons & history: DeepStateMap.live (CC BY-NC-SA 4.0)
• Base map: OpenFreeMap / OpenMapTiles / © OpenStreetMap contributors
• Map library: MapLibre GL JS (BSD-3-Clause)
• News: BBC, The Guardian, NYT, Al Jazeera, The Kyiv Independent, Ukrainska Pravda, Ukrinform, Euromaidan Press, European Pravda, Militarnyi, ArmyInform, TASS
• Concept: IranWarLive
• Built with: Claude — Anthropic's Claude Code generated the entire codebase, deployment and documentation.
• Source: github.com/4LaERz0GWNnuZqmnH/ukraine-war-live
• This project is released under CC BY-NC-SA 4.0 — reuse for non-commercial purposes with attribution, share alike (consistent with the DeepStateMap data licence).