Ritesh

Ritesh

Full-Stack Developer

Institute of Technical Education, Research and Managementfull_time, internship, freelance
Open to roles
Problem SolvingCommunicationAgile/ScrumGIT
Re:Bite — 2-Tap Reorder for Weekly Meals

Re:Bite — 2-Tap Reorder for Weekly Meals

People who eat the same lunch every week shouldn't have to rebuild the order from scratch each time — pick the place, re-add each item, redo the customisations, reconfirm address and payment. That's ~10 taps to recreate something they've ordered 20+ times. And when an item is sold out or a price changed, today's apps make them start over instead of fixing it in place. For habitual orderers — office lunches, tiffins, WFH routines — this is exactly where they give up or just call the restaurant. Process I worked back from one job-to-be-done: "get me the meal I always get, in seconds — and tell me if something changed." Two goals only: fewer taps, more trust. I mapped the current reorder journey and counted the taps (~10), then collapsed it to two — tap your usual, tap place order. The real work wasn't the happy path; it was the messes: sold-out items, price changes, closed or delisted restaurants, an address they no longer deliver to, an expired card, a cart under the minimum. I made each one a clear state with a one-tap fix, and had the cart re-check itself after every fix — because removing a sold-out dish can quietly push you below the minimum. I deliberately left out search, discovery and tracking. They'd blur the one moment this is about. Results Reordering a usual went from ~10 taps to 2 — roughly 80% fewer — with nothing re-typed on the happy path. All 8 edge cases get fixed inline without dead-ending the user; the only genuine dead end (a delisted restaurant) sends them somewhere useful instead of erroring. What I'd do next, honestly: run a 5-person tap test to replace my projected numbers with real taps, time and task-success rates — and add "repeat this every week," since the behaviour is clearly a habit, not a one-off. With more time I'd handle a partial restaurant outage item-by-item instead of blocking the wh Reflection Honestly, I optimised for taps before I had real numbers — I should've run the 5-person test first and let the data set the target, instead of designing toward "2 taps" and validating after. I'd also rethink two calls: blocking the whole cart when only part of a restaurant is down (it should drop unavailable items per-item), and treating a price change as a non-blocking warning — for some people that needs an explicit confirm, so I'd A/B it. And I leaned so hard on speed I never checked whether 2 taps feels too fast — people may want a beat to feel in control before paying.

9 media files · rebite-reorder-743502904048.asia-south1.run.appView
Queue Cure '26

Queue Cure '26

Clinics still run on paper tokens: a receptionist calls numbers out loud while a printed board lags behind. Patients can't tell if they're 2nd or 20th, or how long the wait is — so they keep walking up to the desk to ask. With tens of tokens flowing through one consultation room, the hard part isn't data volume. It's keeping the staff desk and the public display in agreement at every moment, showing a wait estimate people can actually trust, and making sure a single mis-click or double-click never skips a patient. Process I started from the failure modes, not the screens. The biggest risk was two displays disagreeing, so I made the server the single source of truth: every change broadcasts one full snapshot, and the screens only render it — they never calculate queue state on their own. I first tried sending small "delta" updates, but that caused ordering bugs and missed events on reconnect, so I dropped the idea. For concurrency I used Node's single thread to my advantage: keeping every state change fully synchronous makes each one atomic with no locks, and a synchronous save keeps memory and disk in step. Only then did I harden the human edge cases — undo, a call-next cooldown, role-gating, input sanitization — and lock the behaviour down with 32 automated tests before spending any tim Results Both screens stay in sync with zero refreshes — every update reaches all connected screens in under a second (~300 ms in my tests), and a dropped client reconnects to the correct state on its own. Calling the next patient is one tap, or a single key press. The server survives a restart without losing the queue or reusing a token number. And the quality is measurable, not assumed: 32 of 32 automated tests pass — covering live sync, persistence, and every edge case — with 0 vulnerabilities in the dependency audit. Reflection Two honest things. First, I built the frontend and backend on mismatched ports and only caught the broken connection when I finally ran them together — I'd write that integration check on day one, not last. Second, I designed for a single consultation room; a clinic with several doctors needs per-room queues, and my call-next cooldown is a sensible heuristic for one room, not a guarantee for many. Next time I'd model multiple rooms from the start and swap the local JSON file for a real datastore with proper auth, so it could safely handle actual patient data.

4 media files · queue-sync-vue.lovable.appView

This is Ritesh’s work on Wooble.

Build a profile that shows what you can do — and share it anywhere.

Build yours