A gelato counter is asked three things all day, and they have nothing in common except that all three end up on the same piece of paper:
- "What have you got today?" — changes every morning.
- "Does the pistachio have nuts?" — never changes, and has to be answerable in writing at 8pm with two staff on.
- "How much for three scoops?" — changes about once a year.
A menu that stores these three in one structure will be wrong most of the time. The fix is not better design; it is splitting the content by clock speed, and then deciding which of the three clocks belongs on printed paper at all. Here is the model I ended up with, and the two constraints that make it survive a year of real use.
Clock 1 (yearly): price is a function of capacity, not of flavour
The naive model is a grid: every flavour crossed with every size. Twenty-four tubs × three sizes is 72 price cells, and no shop on earth maintains 72 cells — so the grid drifts, and the drift shows up as an argument at the till.
The fix is to notice what is actually being sold. A customer buys "two scoops"; the flavour is a choice inside that purchase. So price belongs to the size, and the flavour list carries names only:
const PRICE = [
{ size: "One scoop", cup: 4.50, cone: 5.00 },
{ size: "Two scoops", cup: 6.00, cone: 6.50 },
{ size: "Three scoops", cup: 7.50, cone: 8.00 },
{ size: "Kids' one scoop", cup: 3.00, cone: 3.50 },
];
const ADD = { topping: 0.75, pint: 9.00, tub1L: 12.00 };
const total = (scoops, { cone = false, toppings = 0 } = {}) => {
const row = PRICE.find(r => r.size.startsWith(String(scoops)));
if (!row) throw new RangeError(`no row for ${scoops} scoops`);
return (cone ? row.cone : row.cup) + toppings * ADD.topping;
};
Four rows instead of 72 cells, and a flavour added on Friday costs nothing to price. The numbers above are a layout example, not a market average — a shop sets its own from its own invoice.
The one thing worth printing under the table is the sentence that kills the remaining ambiguity: the cone, the toppings and the tub are listed above. Small numbers a customer cannot guess are exactly the numbers staff should not be improvising at the till.
Clock 2 (daily): the flavour list, and the sold-out state
The rotation is what makes a printed flavour list absurd: six or eight tubs, one or two rotating, a seasonal flavour that lands Thursday and is gone Sunday. Printing that means printing twice a week and being slightly wrong both times.
The data is small and the state matters:
const today = [
{ name: "Vanilla bean", soldOut: false },
{ name: "Pistachio", soldOut: true },
{ name: "Lemon basil", soldOut: false },
{ name: "Dark chocolate sorbet", soldOut: false },
];
const board = today
.map(f => `<li class="${f.soldOut ? "gone" : ""}">${f.name}${f.soldOut ? " — sold out today" : ""}</li>`)
.join("");
Keeping a sold-out flavour on the list, marked, beats deleting it: the person who drove over for it can see it is gone instead of wondering whether they misread the window. And the shop can mark it in the minute between two customers, which is the only window of time a shop ever has.
Clock 3 (never): allergens, and why the third value is not a fudge
This is the part where a menu stops being a design artefact. The person reading it is deciding whether their child can eat the thing they are about to buy.
Two frameworks cover most of the shops I build for. In the EU and the UK, the fourteen allergens in the food-information rules have to be declared for non-prepacked food too, with written information available where the food is sold. In the US the list is nine major allergens, with sesame added from 2023. Which one applies, and exactly how the notice must be worded, is a question for the shop's local authority — not something a page builder should be interpreting.
What is engineering is the shape. Per flavour, not per shop, and with a tri-state rather than a boolean:
// true = contains, false = does not, "may" = shared equipment / cross-contact
const allergens = {
"Vanilla bean": { milk: true, egg: true, gluten: false, nuts: false, soya: false },
"Dark chocolate sorbet":{ milk: false, egg: false, gluten: false, nuts: "may", soya: "may" },
"Pistachio": { milk: true, egg: true, gluten: false, nuts: true, soya: false },
};
"may" is not a hedge, it is the honest value for a kitchen that also handles nut paste, and collapsing it into false is how a menu becomes a liability rather than a document. The complement is a cross-contact sentence in the shop's own words — made in one kitchen that also handles milk, eggs, wheat, peanuts and tree nuts; we cannot promise any scoop is free of traces — plus a visible pointer to the written list at the counter.
The invariant: print the address, not the snapshot
Everything above can live on a page. The printed artefact has exactly one job, and it is not to carry any of this data: it carries a pointer that stays correct while the data changes.
That is arithmetic, not taste. A photo of the board or a PDF of this week's menu is uploaded to a new URL each time it changes, so a code printed last month points at last month's file — and after two rotations it is a dead link on the window of a shop that already paid for the print. A page keeps its address, so one code survives every flavour change, every price change and every sold-out morning.
The corollary is a constraint on the URL itself: it has to stay short enough to keep the module count (and therefore the ink and the physical size) down. I measured this on this site's own generated PDFs: the same destination as a 40-character tracking URL versus a clean path changes the code from 33 modules to 41 squares across, which is roughly a quarter more ink for the same information. Print the short one; measure the code at the real viewing distance rather than trusting the screen.
The millimetres, since they decide whether it scans
Measured in the PDFs our print kit generates (error correction M, four-module margin), not estimated:
| Piece | Sheet | QR code | Reads at |
|---|---|---|---|
| Counter card | 93.0 × 127.5 mm | 48 mm | ~0.5 m — the person paying |
| 70 mm sticker | 70 mm round | 40 mm | ~0.4 m — hand height, standing still |
| A4 window poster | 210 × 297 mm | 126 mm | ~1.3 m — nose against the glass |
The distances follow the industry rule of thumb of one unit of code per ten units of distance. That rule is not part of the QR standard (ISO/IEC 18004), and it is a floor: behind glass that reflects a bright street, or on a sheet that has bowed in a damp shop, plan for one per eight.
Placement matters more in a scoop shop than in most: the poster belongs behind the glass, not taped outside where it is wiped and sun-bleached; the counter card belongs where the second person in the queue can read it while the first is paying; and the sticker belongs at hand height on a surface that stays dry, because 40 mm of code reads at 0.4 m and a door is read from further away than that.
What the page must not try to be
It must not take orders, take payment, run a loyalty card or talk to the till. Those are separate systems with their own monthly prices, and quoting those prices from memory is how a comparison becomes a rumour. The page's job is narrower: it replaces the paper that keeps going out of date, and the four sentences a staff member repeats across a busy counter.
If you are building anything for a shop like this, the useful exercise is to take each fact on their current menu and ask how often it changes. The yearly ones go on the wall. The daily ones need an edit path that works between two customers. The ones that never change need to exist in writing, in two places, and be readable by someone who is not asking a favour.
I build these pages and print the QR pieces that go with them: a free one-page shop site in about 30 seconds, and a one-off printed kit — the ice-cream guide, the $49 kit for a shop with no tables, and the three-year cost calculator for comparing a subscription against a one-off. The allergen paragraphs here are a description of two regulatory frameworks, not legal advice.
Top comments (0)