Open protocol proof / controlled live pilot next
Not another pizza app.
Pizza4People is a public proof of a small model: a pizza shop can keep its own menu, take direct pickup orders, and start with pay at pickup while the customer can still discover the shop through a public registry.
Why now
Just Eat is leaving Denmark. Platform dependency becomes visible.
Just Eat Takeaway.com has confirmed that operations in Denmark end on 30 April 2026. This is not only a story about one app. It exposes a deeper question: who owns the digital contact layer between restaurants and customers?
Pizza4People does not answer with another closed marketplace. It asks a narrower question: can basic discovery, menu access and order submission be an open protocol instead of a platform silo?
What can be written now
- A pizza shop can keep its own menu and take direct pickup orders.
- Discovery can stay public without the platform owning the order flow.
- It is not production-ready restaurant infrastructure yet.
- The next step is independent node tests and a controlled restaurant pilot.
System in one page
Registry discovers. Node owns. Client talks directly to node.
Core flow
Client
Finds restaurants, renders menus, sends orders.
Registry
Discovery, heartbeat and public node metadata.
Restaurant node
Menu, order endpoint, status, identity and operator control.
Registry is used for discovery. Menu and order flow go directly from client to restaurant node.
Layers
Open base first. Commercial services on top.
This is the short shop-owner reading of the current stack. Full module and provider pages live on the Pizza4People site itself.
The shop keeps menu and prices
The shop can change items, prices, and what is active instead of waiting for a platform back office.
Customers can order direct
The customer opens a simple menu and sends the order straight to the shop instead of through a marketplace flow.
Customers can check order status
When the shop updates the order, the customer can see whether it is accepted or ready instead of having to call.
Start with pay at pickup
The first live shape is deliberately simple: order online, pay when the customer arrives.
Current status
What is public now, and what gets tested next.
Public now
- Public proof site: pizza4people.com
- Umbrella site: protocols4people.com
- Public GitHub repository with spec, schemas and reference code
- Independent node implementer kit
- Reference registry, client and node foundation
Next practical test
- Two or three independent people build their own nodes.
- Each node is tested with the same checker.
- All nodes announce to the same registry.
- The client discovers nodes and sends direct test orders.
- The first restaurant pilot runs pickup-only and only with explicit live mode.
Pilot topology
Primary registry
First discovery endpoint.
Backup registry
Separate server for discovery failover.
Restaurant-owned node
Menu, order mode, order state and operator control.
Client
Finds via registry. Talks directly to node after discovery.
Pilot surfaces
What the local node looks like in the controlled pilot
This is not the current v0.1 proof. It is the next gate: the local control rooms and module surfaces the restaurant owns itself.
The local operations room for orders, kitchen flow, and node status. Part of the controlled pilot, not the current v0.1 proof.
/operator
The menu and catalog truth are edited locally on the node instead of living inside a marketplace backoffice.
/operator/catalog
The shop can see which modules run now, which are desired after restart, and when the runtime honestly needs a restart.
/operator/modules
The Discover room connects the public module catalog to the local node without turning the node into an app store.
/operator/discover
A homebuilt or external module can become visible on the node as metadata before it becomes part of the runtime.
/operator/import
A module can have its own local page with purpose, boundaries, status, and actions instead of being only a technical row.
/operator/modules/view/p4p.catalog.import.ocr
Protocols4People gives the generic human reading of the shop modules before the local node rooms and GitHub contracts.
/protocols4people/modules/shop/
Technical verification
Others can build their own node and test against the contract.
The important part is not that one reference implementation works. The important part is that others can implement the same small contract and still interoperate.
The public repository includes an implementer kit and a dependency-free checker for the minimum node surface.
Minimum node API
GET /p4p/infoGET /p4p/menuPOST /p4p/order
Checker
python3 scripts/check-node.py --node-url http://localhost:8101/p4p
python3 scripts/check-node.py --node-url http://localhost:8101/p4p --test-order
Press angles
Three ways to cover the story without overstating it.
Denmark / Just Eat
From the country where Just Eat began, an open protocol proof appears around the platform's Denmark exit.
Open web / protocol
Can local commerce get an open base layer before commercial services are added?
Foodtech / restaurant
The restaurant's digital identity, menu and order endpoint can stay with the restaurant.
Contact
Dennis Hedegreen
Hedegreen Research
hedegreen.research@gmail.com
Accurate status line: Pizza4People is a public open-protocol proof. The next step is independent node interoperability and a controlled live pilot. It is not a finished restaurant platform.