# Piqero

**Order and pay at the table.**

Piqero is a platform for restaurants and for the venues that share a place: orders, tables, kitchen and checkout. I co-founded it and build all of it — product, design and code. It is in production, and no venue is using it yet.

- Role: Co-founder and developer.
- Period: 2026 — now
- Status: Active
- Work: Product, Full-stack, Design, Business
- Site: https://piqero.app

## The problem

A restaurant runs on information that will not sit still. Which table ordered
what. What the kitchen has actually started. What has been paid and what has
not. Who is allowed to void a line.

Most venues hold all of that in a mix of paper, shouting, and a point-of-sale
system that was designed before smartphones. It works, in the sense that
people are fed. It fails in a specific way: nobody can answer a question about
the last hour without walking somewhere and asking a person.

The software that exists to fix this is either built for a chain of two
hundred venues and priced accordingly, or it is a menu in a PDF.

## Where it came from

In our third year of school, a team of four built **Pedilo**: a menu you could
order from at the table, which worked for exactly one restaurant. That became
**Restoman**, the version for many venues, which we launched at Bibi's in
September 2026.

The multi-venue idea came from a dinner where someone explained how shopping
centres work. Walking home I realised the interesting version was not one
restaurant: it was connecting the restaurants that share a place — each one
running its own orders, with one system tying them together.

In October 2026 the team split up, and Piqero is what I have been building
since.

## The constraints

Still in secondary school. No funding. And the one that shaped every decision:
**a venue has to keep serving customers while we install it.** Nothing can
require the staff to stop and learn a system, and nothing can have a step that
only works if someone remembers to do it.

## What it actually is

Not one app. Five, in a Turborepo monorepo on Bun workspaces:

- **`api`** — the whole domain. **Elysia**, typed end to end, with an OpenAPI
  document the frontends consume through **Eden Treaty**, so a change to a
  route is a type error in the console rather than a bug in production.
  **Better Auth**, **Drizzle** over **Postgres**, **Redis**.
- **`operator`** — Next 16 and React 19. What the business uses: venues,
  menu, orders, kitchen stations, the register, the floor plan, roles and
  plans. One console that adapts from a phone at the pass to a desktop in the
  office.
- **`diner`** — Next 16. What the customer uses. You get in by scanning the QR
  on your table. Works as an anonymous guest or with an OTP account, because
  asking someone to make an account before they can order a burger is how you
  lose the order.
- **`admin`** — where we manage plans, trials and customers.
- **`landing`** — the public site, with a demo you scroll through: an order
  goes from the customer's phone to the kitchen and the till, and you can take
  over at any step.

Plus shared packages that exist because two apps needed the same answer:
`permissions` (the RBAC vocabulary and a pure resolver, used by both the API
and the role editor, so the thing that grants access and the thing that draws
the UI cannot disagree), `ui` (the design system — Base UI, CVA, Motion,
tokens mirrored from Figma), `features` (feature flags), `schemas`, `i18n`,
`logger`.

## What I decided

Five calls I made and would defend.

### Our own organizations and RBAC instead of the auth plugin

The plugin models a flat company: members, roles, done. A restaurant group is
a hierarchy — group, venue, floor, station — and a permission has to inherit
downward through it while **never** escalating upward or sideways.

The alternative was keeping the plugin and modelling the hierarchy beside it,
consulted after the plugin answered. It would have worked, and it would have
meant two sources of truth for one question. Every check would have had to ask
both and reconcile them, and the first time they disagreed we would have had a
security bug rather than a rendering bug.

So it is our schema, with inheritance resolved **per permission** rather than
per role: not "a manager can do X" but "this permission inherits downward from
the scope it was granted at". More code, and we own it. Worth it, because
permissions are the one part of this system where approximately right and
wrong are the same thing.

### A dish's position belongs to the relationship, not to the dish

An item appears in several contexts — the menu, a section, a kitchen station —
and can be ordered differently in each. Making position a column on the item
forces one global order for everything. Making it a property of the
context-item pair means **not ordering is simply inheriting**.

That one is implemented and marked for rework. It works, and moving a single
item writes N rows. I would rather say that here than have someone find it.

### The cache is fail-open, asymmetrically

A cache miss degrades to a slower read. A cache error must never degrade to a
wrong permission. And ephemeral tokens live outside the cache entirely,
because they are not cache — they are state that happens to expire.

### Diner overlays portal into the venue's theme scope

Each venue themes its own diner app. Modals rendered at the document root
escaped that scope and came out unstyled. The fix is small; the rule it
produced is the useful part, and it is written down so it cannot be
rediscovered.

### The register is a screen for taking money, not a report

Researched against Toast, Fudo and Mercado Pago before drawing anything. The
thing all three get right is that the person at the till is under time
pressure and everything on screen is either the amount or in the way.

## Where it is

In production at **piqero.app**: the console, the diner app, the admin and
the API. **No venue is using it yet.**

The next venue gets onboarded the way
[the Bibi's launch](/notes/restoman-bibis-launch) taught us: someone there
while it happens, the full flow tested before the first service, and payments
connected and tried before launch day, not discovered on it.

## What I would do differently

Start the design system before the screens, not after. Revisit ordering per
context before it grew a second implementation on top of it. And build the
monitor that touches the database before the first client, not after the
first night it would have caught something.

---

Page: https://eitanf.com/work/piqero · Español: https://eitanf.com/es/work/piqero.md · llms.txt: https://eitanf.com/llms.txt
