FindMyFood

Walk in without walking in.

Comment

Overview

We've all been there — you call a restaurant to check if there's a table, get put on hold, and either show up anyway hoping for the best or give up and order in. Or you use an app that says "reserve for 7:30 PM" — but you still walk in to find the only available spot is wedged between the kitchen door and a crying toddler.

FindMyFood is a two-sided table booking platform inspired by the way BookMyShow transformed movie ticketing. Just as you'd pick your exact seat in a theatre, FindMyFood lets diners browse restaurants, see a live interactive floor plan, and tap the exact table they want — before they even leave home. No queues. No calls. No surprises.

Restaurants get a real-time manager dashboard for handling walk-ins, reservations, and no-shows — all from the same live floor view their diners see.

Inspiration

The idea behind FindMyFood is simple — and it came from one place: BookMyShow.

Every time you book a movie ticket, you see the entire theatre laid out in front of you. You pick your exact seat — front row, back corner, right next to the aisle — and you know exactly where you'll be sitting before you even leave home. That level of transparency and control is something we take for granted in cinema today. So why doesn't the same exist for restaurants?

When you "reserve a table" at most places, you're not really reserving anything specific. You pick a time, show up, and get pointed to wherever is convenient for the staff. Want a quiet corner by the window? Hope for the best. Prefer sitting close to the entrance? Good luck mentioning that over a phone call.

That equation is what FindMyFood is built on. If a theatre can show you seat G7 in the third row from the back, a restaurant should be able to show you Table 4 by the window — and let you book it before you even step out the door.

Dining is a personal experience. Where you sit shapes how the meal feels — a window seat for a quiet evening, a spot near the reception for a quick lunch, a corner table for a private conversation. FindMyFood gives diners that choice, and gives restaurants a smarter way to manage it.

What it does

FindMyFood is built for three kinds of people — the diner who wants to eat, the manager who runs the floor, and the admin who sets it all up. Each gets their own experience, all powered by the same live data underneath.

🪑 For the Diner — You're in Control

Forget calling ahead and crossing your fingers. Open FindMyFood, browse restaurants near you, check live availability at a glance, filter by price, sort by popularity — and when something catches your eye, go deeper.

You'll see the menu. The reviews. The operating hours. And then — the part that makes FindMyFood different from anything else out there — the floor plan.

Not a generic "Table for 2 at 7:30 PM" dropdown. An actual, interactive map of the restaurant floor. Every table is right there in front of you — its shape, its size, how many people it seats, exactly where it sits in the room. 🟢 Green means it's yours for the taking. ⬜ Grey means someone else got there first.

Want the table by the window? Tap it. Prefer the quiet corner away from the entrance? It's yours. Bringing a large group that needs two tables pushed together? FindMyFood handles combined bookings too — just pick the group, and both tables are held for you in the same instant.

Once you've chosen, you set your date, your time, and how long you plan to stay — 1 hour, 1.5, or 2. Confirm, and you get a 6-character booking code. That's it. No account. No password. No app to download. Just a code you can look up anytime to view, manage, or cancel your booking.

You booked a table the same way you'd book a movie seat — and you knew exactly what you were getting before you walked in the door.

📋 For the Manager — The Floor, Live and in Real Time

Running a restaurant floor is controlled chaos. Walk-ins show up unannounced. Reservations are late. Tables turn over faster than your system can keep up. FindMyFood gives managers one screen that reflects everything — right now.

Managers get a private dashboard, accessible via a secure link, that shows the exact same floor plan diners see — but with full control over every table on it.

Every colour tells a story:

  • 🟢 Green — available, open for walk-ins or incoming reservations
  • 🟡 Amber — held, a diner has locked this table and is on their way
  • 🔴 Red — occupied, someone is seated and dining right now A walk-in just showed up for three? Tap any green table, mark it occupied — done. A reservation just arrived? One tap moves it from held to seated. Someone's a no-show? Mark it, free the table, and move on. The floor plan updates instantly, and an upcoming reservations panel keeps refreshing every 4 seconds so nothing slips through.

No spreadsheets. No sticky notes. No shouting across the floor. Just a live, accurate picture of your restaurant — at all times.

Managers can also edit everything about their restaurant from a settings page — menu, operating hours, floor plan layout, combinable table groups, landmarks — without touching any code.

⚙️ For the Admin — Set It Up, Then Step Back

The admin panel is where restaurants are born. Create a new restaurant with a structured form, watch a live SVG floor plan preview update as you build it, define which tables can be combined for larger groups, and set up visual landmarks like the bar, entrance, or windows. Once it's live, the admin can deactivate restaurants temporarily or delete them entirely with a full data cascade that leaves nothing behind.

How we built it

FindMyFood is a full-stack application built with a modern, production-grade tech stack — with Claude Code in VS Code as a key part of the development process.

🧰 Tech Stack

| Frontend : React 19 + Vite + Tailwind CSS 4 | | Backend : Node.js + Express 5 + TypeScript | | Database : PostgreSQL on Neon (serverless) | | ORM : Drizzle ORM + raw SQL for transactions | | Auth Model :Unguessable UUID tokens in URLs | | Deployment : Vercel (frontend) + Render (backend) | | AI Assistant :Claude Code (VS Code Extension) |

🤖 The Role of Claude Code

Claude Code in VS Code was a development partner throughout, not just autocomplete. The most complex parts of the codebase, the atomic double-booking SQL logic, the SVG floor plan renderer, and the multi-table transaction system, were built and debugged with Claude Code's help. When something broke, it could look at the code in context, understand the intent, and pinpoint the issue fast. It turned hours of potential debugging into focused, quick fixes.

🏗️ The Three Sides

1. Diner Side : Browse restaurants, view the live interactive floor plan, tap a table, pick a date and duration, and walk away with a 6-character booking code. No account needed, no friction.

2. Manager Side : A real-time dashboard showing the floor live. Seat walk-ins, confirm arriving reservations, and mark no-shows — all with a single tap. Auto-refreshes every 4 seconds.

3. Admin Side :Create and manage restaurants via a structured form with a live SVG preview. Deactivate or delete with full data cascade.

Challenges we ran into

  1. Double Booking

Two diners booking the same table at the same millisecond was a real threat. A simple "check then book" approach fails under concurrency — we had to push the logic into a single atomic SQL UPDATE ... WHERE status = 'available' RETURNING id so the database itself becomes the gatekeeper. If zero rows are returned, the table is already taken and the booking fails with a clean 409 Conflict — no race condition, no duplicates, ever.

  1. Group Booking

When a party size exceeds a single table's capacity, multiple tables need to be held simultaneously — and if any one of them fails, all the others must roll back instantly. This required wrapping the entire operation in a Neon HTTP transaction, so group bookings are atomic end-to-end: either every table is held, or none of them are.

  1. SVG Floor Plan

Storing table positions as fixed pixels meant the floor plan would break on different screen sizes. The fix was storing positions as percentages so every table renders correctly at any resolution. Making every table tappable, visually accurate, and state-aware (available / held / occupied) in real time — all from a single shared data model used by both diners and managers — took careful coordination between the frontend renderer and the live backend state.

Accomplishments that we're proud of

The biggest achievement? Innovation.

The idea of booking a restaurant table the same way you'd book a movie seat — seeing the actual floor, picking your exact spot — may sound obvious in hindsight, but nobody had quite done it this way before. Taking that idea seriously meant confronting a lot of real loopholes, edge cases, and hard problems that come with it. Each one needed a proper solution, not a workaround.

Here's what I'm proud of pulling off:

  • The atomic double-booking guarantee
  • An interactive SVG floor plan
  • No-login architecture
  • A real-time two-sided marketplace

What we learned

There was quite a lot learned on this journey — some technical, some very human.

  1. Get a good night's sleep. Seriously. Some of the worst bugs and most confusing decisions happened late at night, and most of them looked obvious the next morning. Rest is part of the process.
  2. Concurrency is a database problem, not an application problem. The double-booking issue made it clear — some problems can't be solved in JavaScript. You have to push them down to the database level and let it do what it's built for.
  3. Simplicity beats complexity. Polling over WebSockets. UUID tokens over a full auth system. Booking codes over user accounts. Every time the simpler path was chosen, the app got better — not worse.
  4. Scope discipline is a skill. Knowing what not to build — no payments, no map view, no WebSockets — kept the core experience tight, focused, and actually shippable.

What's next for FindMyFood

FindMyFood in its current form is a working prototype — and a solid one. But the vision is bigger than this.

The next step is to layer in premium, user-friendly features that take the experience from functional to exceptional:

  • 🗺️ Map View — Discover restaurants around you visually, not just as a list
  • 💳 Payment Integration — Deposits and prepayments at booking time to cut down no-shows
  • 📱 Mobile App — A native iOS and Android experience built for the floor plan interaction
  • ⭐ Reliability Score — Track diner history, reward regulars, and give restaurants the trust signals they need Beyond features, the next milestone is full-scale deployment — onboarding real restaurants, running proper marketing across platforms, and growing FindMyFood from a hackathon prototype into a product people use every day.

Built With

Share this project:

Updates