Piqero
Order and pay at the table.
- Role
- Co-founder and developer.
- Period
- 2026 — now
- Status
- Active
- Work
- Product · Full-stack · Design · Business
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 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.