
Full Stack Challenge: ForkPoint
ForkPoint is a group decision app that ends the endless "where should we eat" debate. Friends join a live "Craving Lobby" with a short code, secretly rank their food mood (comfort, spicy, light, or treat), and optionally tell an AI chat about dietary needs or things to avoid.
Word: Compass. Built solo in 48 hours, from Madurai, Tamil Nadu. Never argue about where to eat again.
Vision and What It Does
Anyone who has ever tried to organize dinner with more than two other people knows exactly how this goes. Someone throws out "biryani?" Someone else says "not again, we had that Tuesday." A third person types "I'm okay with anything" — which, if you've been in enough group chats, you already know is a lie. Fifteen minutes later nobody has moved, the group is hungrier and crankier than when it started, and the decision usually gets made by whoever gives up first and just picks somewhere.
That fifteen-minute WhatsApp spiral is the actual problem ForkPoint solves. It's a small thing, but it happens to almost everyone, almost every week, and no one has really built for it properly — most "restaurant decision" apps are single-player, built around one person's taste, not a table full of conflicting ones.
Here's how it works in practice. One person opens ForkPoint and starts a Craving Lobby for their city — right now that's Madurai, Chennai, or Trichy, the three cities I know well enough to ground this app in real places instead of guesses. That creates a short join code, something you can read out loud across a table or drop into the group chat. Everyone else joins with their name and that code. Then, privately, each person ranks their mood for the meal — Comfort Food, Spicy, Something Light, or Treat Yourself — in whatever order actually reflects what they're craving. Nobody sees anyone else's ranking. That secrecy matters more than it sounds like it should: people vote differently when they know their friend is watching and might judge them for wanting to "waste" the group's veto on dessert.
Alongside the vote, there's Ask ForkPoint — a small chat window where anyone in the group can type something in plain English: "someone's vegetarian," "we had pizza yesterday, please not again," "keep it under ₹500 a head." ForkPoint reads that, in real time, and folds it into the group's constraints for everyone to see.
When enough people have voted — or when the host just decides to go for it — someone taps "Spin the Compass." This is the part I'm proudest of. ForkPoint doesn't do the boring thing and just count first-choice votes. It runs every real restaurant in that city's curated list against every person's ranking, works out how satisfied each individual person would be with that restaurant, and then deliberately weights the least satisfied person's score more heavily than the average. A restaurant that thrills three people and leaves the fourth with literally nothing to eat cannot win. Once it has a winner, it asks Amazon Bedrock to write, in plain human language, why that specific restaurant is the fairest compromise for this specific group — not a generic blurb, an explanation that actually references the tension it resolved.
The word of the challenge was Compass, and it's not a decorative metaphor here — a compass doesn't pick the direction you wanted, it points to the direction that's actually true. ForkPoint is built to do the same thing for a hungry, indecisive group: find the direction that's fair, not just the one the loudest person shouted for.
This is built for real groups — friends catching up after work, families arguing about where to take visiting relatives, coworkers who can never agree on a lunch spot — in cities that most food-tech products simply don't bother building for. I live in Madurai. I wanted this to work for the temple-town lunch crowd and the Chennai IT-corridor dinner group just as well as it would for a demo audience in San Francisco, so the restaurant data behind it is real, verified, and specific: Murugan Idli Shop, Amma Mess, Zaitoon, Vasanta Bhavan — places that actually exist and that I or people I trust have actually eaten at.

Full Stack Breakdown
The Full Stack series walked through pitch, prototype, MVP, UX, and launch as five distinct muscles, and building ForkPoint in a real 48-hour window made all five of them show up in a way a slower project never would have.
Pitch. The very first version of the idea in my head was "an app that recommends a restaurant." That's not a pitch, that's a feature that already exists in five different apps. The pitch only became real once I reframed it: this isn't about recommending a restaurant, it's about resolving a disagreement between people who each want something different. The moment I said it out loud that way, it stopped being "yet another food app" and became something with actual teeth — a consensus engine wearing a food app's clothes.
Prototype. Most people would prototype the UI first. I didn't. The part of this idea I was least sure I could pull off wasn't the interface, it was the fairness math — what does it even mean for a restaurant to be "fair" to four people who want four different things? Before writing a single React component, I sat with pen and paper working through scenarios: what happens if three people want spicy and one wants light? What happens if someone's dietary restriction eliminates half the list? I landed on scoring every restaurant against every individual vote, then blending the minimum satisfaction across the group with the mean, weighted so the minimum matters more. That formula is the actual prototype — everything else was built around protecting it.
MVP. The smallest version of ForkPoint that could prove the idea worked was brutally simple: create a lobby, vote, decide, see a result — no chat, no personality badges, no dark mode, nothing decorative. I built that loop first, end-to-end, against real deployed AWS infrastructure rather than local mocks, because I've learned the hard way that a loop that "works" against a mock and a loop that works against a real Cognito Identity Pool and a real AppSync subscription are two very different claims. Only once that skeleton could actually create a lobby on one phone and show a decision on another did I let myself add anything else.
UX. I gave myself a very specific design brief before opening a single CSS file: "warm, playful maximalism." Chunky borders instead of thin ones. A palette that felt like a Saturday afternoon appetite — burnt orange, creamy background, deep espresso, golden-hour yellow — instead of the cool blues every SaaS product defaults to. And the compass itself had to visibly spin and land when a decision arrives, because the whole emotional payoff of this app is that one moment. If that moment feels like a form submission, the app has failed at its actual job. I also added a full dark mode toggle (🌞/🌚) that lives on every screen, remembers your preference in local storage, and respects your system's color scheme the first time you open the app — a small thing, but the kind of small thing that makes an app feel finished rather than just functional, especially if you're deciding on dinner from a dark restaurant or a dim living room at 9pm.
Launch. Shipping meant something more specific than "it runs on my machine": it meant it had to survive actually being deployed to a real AWS account, with real IAM permissions, real region constraints, and real errors that only show up once money and infrastructure are involved. That turned out to be where most of my actual engineering time went — which is exactly the next section.

How I Built It
The stack: Python CDK for every piece of infrastructure, React + Vite for the frontend, Amazon Bedrock's Nova Lite and Nova Pro models for every AI-powered moment in the app, all deployed to us-west-2.
I made a deliberate choice not to do spec-driven development for this challenge — I wanted to be building within the first hour, not writing requirements documents. But "start immediately" didn't mean "guess and hope." Before I wrote a single stack, I went through the actual AWS documentation for AppSync's Lambda resolver patterns, Bedrock's regional model availability, and DynamoDB's IAM-permission shapes, so that the decisions I made in hour one wouldn't need to be unmade in hour thirty.
A few decisions shaped everything downstream:
No login, by design. ForkPoint is meant to feel like a party game you join with a link, not a product you sign up for. So instead of Cognito User Pools, I used a Cognito Identity Pool configured for unauthenticated identities only — the browser gets short-lived, scoped IAM credentials the instant it loads, no email, no password, no friction. The honest tradeoff is that anyone holding the join code can act as any member of that lobby. For a group decision game played among people who are, by definition, already in the same room or chat together, that's an acceptable risk — but it's one I want to say out loud rather than bury.
Real restaurants over live lookups. My first instinct was to wire up Amazon Location Service and let it search for restaurants dynamically. I tested it against Madurai and Trichy first, and the point-of-interest coverage for Tier-2 Indian cities on the underlying map data providers was thin enough that it would sometimes miss well-known local landmarks entirely. Rather than ship a demo that might confidently return nothing for "Jigarthanda near Meenakshi Temple," I hand-built a curated dataset of twenty real, verifiable restaurants across the three cities, each tagged with honest mood, cuisine, price, and dietary data. It's less "impressive" on an architecture diagram than a live geocoding call. It's also something I can vouch for personally, which matters more to me.
Two AI models doing two different jobs. Amazon Nova Lite handles everything that happens often and cheaply needs to happen fast — parsing a chat message into a structured constraint, generating someone's evolving "Food Personality" badge. Amazon Nova Pro is reserved for the one expensive, high-value call per session: writing the actual pitch, dish recommendation, and consensus explanation once the group has decided. That split keeps the app fast where speed matters and thoughtful where thoughtfulness matters.
The challenges — told straight, because I think they're the most useful part of this whole writeup:
The first real wall I hit was Amazon Bedrock refusing to invoke Nova Pro from
us-west-2 at all. The error was ValidationException: Invocation of model ID ... with on-demand throughput isn't supported. Retry your request with the ID or ARN of an inference profile that contains this model. It turns out Amazon Nova models are natively hosted only in us-east-1 — every other commercial region, including the one I'd chosen, can only reach them through a geographic cross-region inference profile. The fix wasn't just swapping a model ID string; it meant granting IAM permissions on two separate ARN shapes — the inference-profile ARN itself, and the underlying foundation-model ARNs in every region that profile might dispatch to. That's not something you'd guess without reading the actual IAM policy documentation for cross-region inference, and it's now a pattern I'll recognize instantly next time.Right after fixing that, I hit two DynamoDB errors back to back that turned out to share one root cause: I hadn't yet internalized how strict boto3's DynamoDB resource API really is. First,
constraints — a perfectly reasonable attribute name — turned out to be one of DynamoDB's roughly three hundred reserved keywords, so it couldn't appear directly inside an UpdateExpression without an alias. Then, the very next test run, decideNow failed with Float types are not supported. Use Decimal types instead — because my matching algorithm's scores were plain Python floats, and boto3 flatly refuses to write those. I didn't want quick patches that would resurface as new bugs later, so I built a small shared helper that recursively converts floats to Decimal on the way in and back to native numbers on the way out, and used it consistently everywhere a decision gets written or read.The smallest but funniest bug was a stale dependency: I'd pinned an alpha CDK package for Cognito Identity Pools, and by the time I actually ran
cdk deploy , that construct had already graduated into the stable aws-cdk-lib package and the alpha module no longer existed at all. A five-minute fix, but a good reminder that infrastructure-as-code dependencies age faster than you expect, especially mid-challenge when everyone's CDK CLI versions drift.
AWS Services / Architecture
Every piece of this app is serverless and event-driven, which felt right for something that gets used in short, spiky bursts — a group deciding on dinner, then going silent for hours — rather than constant traffic.
- AWS AppSync is the real-time backbone of the whole product. It's a GraphQL API secured entirely with IAM auth, exposing mutations for creating and joining lobbies, submitting a secret vote, chatting with Ask ForkPoint, and triggering a decision — plus subscriptions that push live updates to every connected member the instant something changes, which is what makes the lobby feel alive instead of like a page you have to keep refreshing.
- AWS Lambda (Python 3.12, sharing one common layer for code reuse) does all the actual work behind those GraphQL operations — seven small functions covering session and vote logic, the AI concierge, the consensus decision engine, and asynchronous food-personality generation.
- Amazon DynamoDB holds five on-demand tables: Sessions, Members, Votes, DecisionHistory, and FoodPersonality. The ephemeral ones carry a TTL so old, finished lobbies quietly clean themselves up instead of accumulating forever.
- Amazon Bedrock, specifically Amazon Nova Lite and Amazon Nova Pro, is what makes ForkPoint feel intelligent rather than mechanical — parsing natural language into structured constraints, writing restaurant pitches and dish recommendations, explaining group consensus in plain English, and generating each person's evolving Food Personality.
- Amazon Cognito Identity Pool hands out scoped, temporary IAM credentials to unauthenticated browser sessions, which is the entire reason there's no login screen anywhere in this app.
- Amazon EventBridge carries a single, deliberate event —
DecisionFinalized— from the moment a decision is made to the Lambda that generates everyone's food personality, so that "nice to have" AI flourish never delays the group from actually seeing their restaurant.
- Amazon CloudWatch captures logs from Lambda and AppSync for anything that needs debugging after the fact.
Architecture Diagram

App-flow Diagram

What I Learned
I went into this challenge already comfortable with AWS, but comfortable is not the same as battle-tested, and this project found the gaps between those two words pretty quickly.
The biggest one was realizing that a model being "available" in a region and a model being directly invocable in that region are two different claims, and Bedrock's documentation draws that line very precisely if you actually read it — In-Region, Geo Cross-Region, and Global Cross-Region are three genuinely different things, not marketing variations of the same idea. I now check that table before writing a single line of Lambda code that calls a model, instead of finding out the hard way at deploy time.
I also came out of this with a much more respectful relationship with boto3's DynamoDB resource API. It has real, documented sharp edges — a reserved-word list long enough to catch you off guard, and a flat refusal to accept native floats — and both are completely avoidable once you know to look for them. What I'm taking forward isn't just "remember these two gotchas," it's the habit of writing one small, well-tested helper for a class of problem instead of patching each symptom individually as it appears.
Probably the thing I'm personally most satisfied by is realizing that the matching algorithm was a product decision as much as a technical one. It would have been easy to ship simple majority voting and call it a day — technically correct, emotionally hollow. Choosing to weight the least-satisfied person's outcome more heavily than the average is what actually makes the app feel fair instead of just being a marginally fancier tally sheet, and that distinction only became obvious to me once I'd sat with the math myself instead of reaching for the first plausible formula.
I also learned something about honesty in engineering that I didn't expect to learn from a hackathon: choosing curated, real data over a flashier live API isn't a compromise, it's sometimes the more honest architecture. It would have looked more sophisticated to wire up a live geocoding service and wave at an architecture diagram with more boxes on it. It would also have occasionally been wrong about a restaurant in my own hometown. I'd rather ship something smaller that I can personally vouch for than something bigger that I can't.
And finally, a smaller but genuinely useful lesson: infrastructure-as-code dependencies drift, even mid-project. AWS CDK constructs graduate out of alpha modules on their own schedule, not yours, and a pinned
requirements.txt can quietly become outdated between the moment you write it and the moment you actually deploy. It's a small thing to watch for, but it's now a habit.
Link to App or Repo
Conlusion
ForkPoint started as a joke about how long it takes my friends to agree on dinner, and ended up teaching me more about AWS regional inference profiles, DynamoDB's reserved keywords, and honest product design than I expected from a 48-hour challenge. What I'm most proud of isn't the tech stack, it's that the fairness math actually works the way I hoped it would — the app finds a restaurant that keeps everyone at the table happy, not just the majority. If nothing else, the next time my group can't decide where to eat, I finally have somewhere to point them.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article