Around the Corner

snapshot of the live orders on the local business side - square
Tiger Data: queries per second, sql query to database, and the output of the sql as three graphs
vultr and containerization with docker (adaptability and future scalability)
geofenced local view

Inspiration

Most of us default to the chain order without thinking: a PSL at Starbucks, a cold brew on the go. Meanwhile, locally owned cafes just a few minutes’ walk away make their own versions of the same drinks, often at comparable or lower prices and with ingredients they’re proud of, like real pumpkin purée instead of syrup. Despite many consumers wanting to support local businesses, big chains are often just more familiar and convenient. The foot traffic goes to the chain, and local shops lose customers despite quality. We wanted to close that convenience gap: say “I’m craving X” and get a nearby local alternative, with a real price comparison against the chain and a reason to go, whether that be finding their favorite drinks, or letting them order the drink beforehand if they’re in a rush.

What it does

Around the Corner helps people find locally owned cafes that make the drink they were about to order at a chain. It has various functionalities:

Search a craving. Type “pumpkin spice latte” or “something sweet” and get nearby local cafes that make it. If the craving is vague, the app will ask what you’re in the mood for.
Compare against the chain. Tap compare to see the chain baseline (approximate, with an as-of date) next to several local shops making the same drink, with the price difference worked out.
Get nudged near a chain. Each chain has a 200 meter geofence. When you walk near one, the app checks where you are and notifies you of the best local shops within walking distance.
Walk there. Tap Show Route to open Google Maps with the exact walking route and time.
Order ahead. For a shop that’s connected, the app sends a pickup order through Square’s Orders API, at our verified price, and it lands on the cafe’s dashboard. Nothing is ordered until the user confirms. This allows small businesses that already use Square for their payments to take pickup orders in a seamless way, greatly increasing convenience for the consumer and business-side profits. When they previously might’ve had to make their own app and handle secure payment tracking, it now integrates through a secure platform they know and use.
Last but not least, track your swaps. The app counts a streak of how many times you’ve chosen local, starting with a “First local swap” moment.

How we built it

App. React Native (Expo) with Google Maps for the map, geofence circles, and walking routes.

Backend. We use Tiger Data to get a single Postgres database, populated by an API and worker which uses the Google Maps API and scrapes coffee shop websites and images to populate the database. Relational data like shops and menus sits next to time-series data like price history and search activity, all in plain SQL. The API and workers run on a Vultr cloud VM, containerized with Docker, so the app talks to one always-on server instead of a laptop, and behaves the same regardless of the machine. Deploying is one command, and as traffic grows we add containers behind a load balancer.

Gemini, the language and vision layer. Gemini never supplies facts about the world on its own. Shops, prices, and distances come from the database and Google Maps.

Menu reading: Gemini turns shop menus into structured JSON with a schema, returning null for anything it can’t read and never guessing a price. It can also read photos of printed or handwritten menus.

Drink matching: Each menu item is matched to one of 74 canonical drink concepts (like pumpkin_spice_latte), with attributes like flavor, temperature, and dairy-free pulled out only when stated.

Search understanding. Plain code handles common aliases like “PSL” instantly. Gemini handles what code can’t, such as “something sweet,” and its output is validated against the concept list.The writer sees only the source text and must attach an exact quote to every claim. A separate Gemini call with a stronger model and a different prompt then splits the story into atomic claims and rejects any without a verbatim supporting quote. This is an extra layer of assurance against lies/hallucination by the AI model. Additionally, because the price comparisons and geofence messages are plain code, the figures used and displayed are consistent.

Reliability. All model work runs at ingestion and is cached, so searching is a database lookup, not a live call, reducing costs. The Gemini wrapper adds per-model cooldowns and fallbacks, which we accounted for in demo day.

Challenges we ran into

One of our biggest challenges was the free-tier quota. Despite actually building out much more robust functionality with our API use, we hit 429s and 503s under back-to-back Gemini calls, which cost us some eval runs. To switch for the purposes of having a working product, we used lighter models, cut down on the use of image text extraction, and built a precomputed fallback so the demo never depends on a live call. In keeping with this, relying less on images made our accuracy difficult to track, as many small businesses don't have their menus typed out (at most, a google review picture). Even when they do, menus often have no prices and we had no owner side, so we chose “Price not listed” over guessing, and a teammate spot-checked random seeded shops.

Accomplishments that we're proud of

We managed to build a verifier that let zero planted lies through during eval runs, alongside code capable of parsing images of printed or handwritten menus. Every function was designed to fail closed and never throw, meaning an odd website can never crash the pipeline.

We kept our numbers consistent by having code handle all comparisons and push messages rather than the model. We are also proud of containerizing a backend framework on a virtual machine geared toward future scalability, while successfully tying together new platforms like Tiger Cloud and Vultr alongside familiar ones like Gemini, Google Maps, and Docker.

We were also proud that we got Square functionality to work well enough to take in live orders and actually display the customer facing experience along with the business backend. It let us take our goal a step further by really reducing the gap so we were excited that something like this (even if its dummy data) was possible in such a short time.

What we learned

We learned firsthand to use code wherever code is enough. Alias matching and arithmetic are faster, free, and exact, leaving Gemini to handle only the fuzzy remainder. We also realized that demo-day reliability comes from caching and precomputing everything you can, rather than hoping external APIs stay up under pressure.

Beyond the technical side, the project taught us a lot about communication and delegation. Because everyone's work heavily relied on each other after a certain point, close collaboration was essential to getting us across the finish line. We also learned that using new technology can come with some frustrations, but it was all worth it when we got things working and realized how important the learning process is.

What's next for Around the Corner

Review-based aspect scores (“good for studying”, service speed), shown with evidence snippets and mention counts
Gemini vision to pick a shop’s best 5 photos (food, drinks, interior) and reject menus, logos, and blurry shots
Photo-of-a-chain-cup search, and a clarify-and-decompose chat for “something like a Big Mac”
More chain reference prices beyond the Starbucks PSL, so more drinks get a “vs chain” comparison
Embeddings for matching as the concept list grows
With more data and computing power, expansion into food, cuisine, etc.
More neighborhoods, and optional cafe-claimed profiles + proper Square backend support