Fast Order ⚡

Paste the warung menu, paste what your colleagues already ordered, press ENTER. An LLM picks your lunch, appends it as the next numbered line, and the whole list is on your clipboard before you've reached for the mouse — ready to paste back into the WhatsApp group.

Stateless. No account, no database, nothing to remember. · v0.2.0

menu + current orders  ──►  POST /api/generate-order  ──►  Go assembles the list
   (two textareas)              (LLM picks the dishes)          │
                                                                ▼
                                              printed ticket + clipboard.writeText()

Paste this into menu:

Menu Redi now 🥰🥰
*ADA NASI MERAH Y GUYS*
Cah kacang pjg tempe
Cah pare
…
Udang crispy telur asin
Beef Sukiyaki oseng paprika cabe iris
Ayam goreng cabe ijo

…and this into orders:

19/8
1.Ariki : Nasi, Cabe Ijo, Rolade Ayam, Nugget, Tahu Isi
…
6.kenji: Nasi 1/2 + rolade ayam+ cah kacang pjg tempe + kentang ayam cincang

…and you get the same six lines back, verbatim, with line 7 added and copied:

7. miftah : nasi 1, udang crispy telur asin, ayam goreng cabe ijo

---

Demo

Everything below comes out of frontend/scripts/capture-media.mjs, driving the app in a real browser against a real backend. Three modes, one keystroke each.

---

Order modes

The mode is inferred from which boxes have content — there is no mode switch to click.

Mode	When	Menu	Orders	Key
First-touch	You're the first to order	✅	—	⇧ENTER in menu
Normal	Others have already ordered	✅	✅	ENTER in orders
Nitro	No menu was shared	—	✅	ENTER in orders

The station label in the header (ready → first-touch / normal / nitro) always tells you which one is armed before you commit.

Keyboard

Key	Action
ENTER (in orders)	print — normal or nitro
⇧ENTER (in menu)	print — first-touch
Ctrl+Shift+C	print, whatever the mode, from anywhere
ESC	clear both boxes and the ticket

The result is written to the clipboard by the app itself, so the whole loop is paste → ENTER → ⌘V back into WhatsApp, without a single click.

---

How it stays fast

• The LLM writes one line, not the list. The backend parses the existing numbering itself and asks the model only for the dishes, then assembles the numbered result in Go (backend/internal/llm/assemble.go). Existing lines come back byte-for-byte — the model cannot renumber, reword or drop someone's order — and the prompt stays short enough to answer in well under a second.
• Measured, not assumed. Every response carries durationMs (server-side LLM time). backend/e2e/ hits a running instance and prints both that and the full client round trip.
• Circuit breaker in front of the provider (gobreaker), so a flapping LLM endpoint fails fast instead of hanging the textarea.
• Nothing is stored. No database, no session, no history. Two textareas in, one string out.

---

Stack

Layer	Choice
Backend	Go 1.24, gorilla/mux, langchaingo, sony/gobreaker
Frontend	React 18, Vite 6, TypeScript 5
Type	Space Grotesk + IBM Plex Mono, self-hosted via @fontsource
LLM	Any OpenAI-compatible endpoint — DeepSeek, OpenAI, or Gemini through Google's OpenAI-compatible URL
Tests	Go testing (+ e2e build tag), Playwright
Deploy	Vercel (two services, one project), Docker Compose, or Render

---

Quick start

Docker Compose (recommended)

cp .env.example .env          # then fill in the LLM credentials
docker compose up -d --build
open http://localhost:5173    # backend on :8089

Manual

# backend
cd backend && cp .env.example .env && go run main.go

# frontend
cd frontend && npm install && npm run dev

vite.config.ts proxies /api to the backend; the nginx image does the same in production via BACKEND_URL. The frontend never needs to know a backend hostname.

---

Environment variables

Variable	Description	Default
LLM_TYPE	Active provider: DEEPSEEK (default) or GEMINI	DEEPSEEK
LLM_API_KEY	DeepSeek/OpenAI-compatible API key	—
LLM_BASE_URL	DeepSeek/OpenAI-compatible base URL	—
LLM_MODEL	DeepSeek/OpenAI model name	—
GEMINI_LLM_API_KEY	Google AI API key (used when LLM_TYPE=GEMINI)	—
GEMINI_MODEL	Gemini model name, e.g. gemini-3.1-flash-lite	—
PORT	Backend port	8080 (compose and Render set 8089)

Set LLM_TYPE=GEMINI to route generation through Gemini — Flash Lite is noticeably faster. It is called via Google's OpenAI-compatible endpoint, so it reuses the same client path, the same prompt and the same circuit breaker; the base URL is a constant in internal/config, not a variable you set.

---

Deployment

Vercel

vercel.json declares both halves of the app as services in one project — the Vite frontend and the Go backend — pinned to sin1, with /api/* and /health rewritten to the backend and everything else to the frontend.

vercel env pull            # or push the vars for Preview + Production
vercel deploy              # preview
vercel deploy --prod       # production

Preview deployments inherit the Preview-scoped env vars, so a preview is a full working app, LLM included. Verify one with vercel curl <url>/health (preview URLs sit behind deployment protection, which vercel curl handles for you).

Docker Compose

docker compose up -d --build     # 5173 → nginx → 8089
docker compose logs -f
docker compose down

Render

render.yaml deploys the same two units: the Go service and the nginx-served static build, with BACKEND_URL pointing the frontend at the backend service.

---

Testing

cd backend && go test ./...        # unit: config, prompt assembly, LLM client
./test-integration.sh              # Playwright against a local dev stack
./test-docker-integration.sh       # Playwright against the Docker stack

Both scripts run Playwright; they differ only in what they point at. Use the first while iterating, the second before a deploy — it validates container health and the nginx → backend hop, which local dev never exercises.

End-to-end, with timings

The Go e2e test hits a live /api/generate-order in nitro mode and reports both the server-reported durationMs and the client round trip. It is behind the e2e build tag, so go test ./... never touches the network or spends tokens.

docker compose up -d --build
cd backend
BASE_URL=http://localhost:8089 go test -tags e2e -v -count=1 ./e2e/...

-count=1 defeats Go's test cache, so each run is a fresh measurement.

---

Regenerating the README media

Every image and GIF above is captured from the running app — real keystrokes, a real LLM round trip, no mockups. To refresh them after a UI change:

docker compose up -d --build            # or npm run dev, with /api reachable
cd frontend && npm run media            # BASE_URL=http://localhost:5173 by default

The script drives Playwright at 560×880, writes the five PNGs at 2× and records the three clips, then converts them with ffmpeg (palettegen/paletteuse, so the flat paper/ink/ember palette survives quantisation). Inputs live in frontend/scripts/fixtures/ — swap those to re-shoot with a different menu. Requires ffmpeg on PATH.

License

MIT