Locus

Your all-in-one housing answer.

Comment

Inspiration

Where you live shapes everything. Your morning routine, your social life, your stress levels, your sense of belonging. Yet most people choose their neighborhood the same way: a rushed Zillow search, a few Reddit threads, maybe a drive through the area on a Sunday afternoon. They pick something that looks fine on paper and hope it feels right in practice. The problem isn't lack of options. It's that no tool has ever asked the right questions. Not "how many bedrooms" but "do you need a park within walking distance or a bar that stays open late." Not "what's your budget" but "what does your ideal Saturday actually look like." People aren't lost because good neighborhoods don't exist. They're lost because the tools built to help them were never built around them. Locus started with one idea. What if finding a neighborhood felt less like a spreadsheet and more like being genuinely understood?

What it does

Locus builds a living profile around you: your commute habits, your weekend rituals, whether you need a park nearby or a bar that stays open late. From that profile, we generate a personalized scoring model that weighs every neighborhood against what actually matters to you, not what matters to the average person. Safety, walkability, transit, schools, green space, nightlife; every factor weighted by your life, not ours. The result is an interactive map that doesn't just show you where to live, it shows you why. Click any neighborhood, challenge any score, and watch the map reshape itself around your priorities in real time.

How we built it

We built Locus around three core pillars: a personalized scoring engine, a real-time data pipeline, and a clean interface that makes complex neighborhood intelligence feel effortless. The frontend is built in React with Framer Motion handling all animations and transitions. We kept the component architecture modular — the input page, neighborhood view, and comparison page each live independently, communicating through a shared Zustand store. This let us build in parallel without stepping on each other. The search experience was a priority from the start. Users can either select from our curated neighborhood dataset or trigger an AI generation flow for any city in the world. When a neighborhood doesn't exist in our database, we call the Gemini 2.5 Flash API with a strict schema prompt that returns a fully structured neighborhood analysis including five categories, scored factors, confidence levels, and real data source attributions. The response streams in real time so users see progress rather than a blank loading screen. Scoring is powered by a weighted factor model where each neighborhood metric has multiple underlying data sources, each with its own weight and confidence level. When a user challenges a score, our recalculate engine adjusts the weights in real time, downweighting estimated sources and boosting measured ones, then recalculates the score and reduces confidence accordingly. This makes the AI's reasoning transparent and user controllable. For real estate listings we integrated the Realtor Search API through RapidAPI with a two layer caching system using memory cache for the session and localStorage for persistence across visits, to avoid redundant API calls and keep the experience fast. Commute estimation uses a haversine distance fallback when a routing API key isn't present, so the feature degrades gracefully rather than breaking. The comparison page computes key differences algorithmically, surfacing the category with the largest score gap between two neighborhoods and generating a carbon savings insight derived from EPA household emissions data mapped across our sustainability scoring scale.

Challenges we ran into

One of our biggest technical hurdles was map shading. Highlighting specific neighborhoods required precise GeoJSON boundary data, and sourcing, cleaning, and integrating that block-level data into a smooth visual layer took far longer than we anticipated. On the design side, we started with two separate UI directions and spent time debating which path to commit to. Rather than picking one and scrapping the other, we identified the strongest qualities from each and merged them into a single coherent interface. It slowed us down early but the final product was stronger for it. Collaboration was also trickier than expected. With only three pages in the app, we were frequently working in the same files at the same time. Managing merge conflicts under time pressure meant we had to communicate constantly about who owned what at any given moment, and occasionally had to wait on each other before committing changes.

Accomplishments that we're proud of

We're most proud of how the AI pipeline came together. What started as rough prompts and back and forth experimentation evolved into a clean, structured data flow that reliably generates beautiful, detailed neighborhood profiles for any city in the world. Turning an open ended AI conversation into a strict schema with real scores, confidence levels, and sourced factors felt like a real engineering win. Getting the map to where it is now is something we're genuinely proud of. It went through three full iterations before it felt right, and pushing through those early failures to land on something polished and functional under time pressure was one of the harder things we did this weekend. The scoring accuracy also exceeded our expectations. The category breakdowns for our curated neighborhoods are remarkably precise, and seeing real places score in ways that actually reflect how those neighborhoods feel validated the entire model we built. Finally, getting every API talking to each other cleanly was no small feat. Gemini for AI generation, RapidAPI for real estate listings, routing estimation, and our internal scoring engine all had to work in harmony. The fact that it all holds together as one seamless experience is something we're proud of as a team.

What we learned

Building Locus taught us that user experience is not something you layer on at the end. Every technical decision we made had a direct impact on how the product felt, and we learned to think about the user's journey first before writing a single line of code. The difference between a feature that works and a feature that feels good is enormous, and that gap is where most of our time went. We also developed a much sharper eye for UI decision making. Having two competing design directions early on forced us to articulate why one choice was better than another rather than just going with gut feeling. That process of defending design decisions made us more intentional about everything from typography to spacing to how information gets revealed. Working with real world datasets taught us that data is never as clean or as simple as it looks. Sourcing neighborhood boundaries, reconciling different API response shapes, and figuring out how to present imperfect information honestly and transparently was a skill set none of us expected to develop at a hackathon. It gave us a lot of respect for the complexity that sits underneath products that look simple on the surface.

What's next for Locus

The most immediate next step is geographic expansion. Right now Locus has deep coverage for a handful of California neighborhoods, but we want to bring that same level of detail to major cities like New York, Boston, Chicago, and beyond. Each city brings new data sources and scoring nuances, and we want Locus to feel locally intelligent no matter where you search. We also want to invest more deeply in profile customization. The current profile captures the most important lifestyle signals, but there is so much more we could learn about a user to make the neighborhood matches feel truly personal. Better profiling means better matches, and that is the core promise of Locus. The feature we are most excited to build is Challenge Mode. Right now users can see how a neighborhood is scored, but we want to give them the ability to push back. If you think a neighborhood's safety score is too low or its walkability is underrated, you should be able to make that argument and watch the model respond. Making AI scoring genuinely contestable and transparent is not just a product feature, it is the direction we think all AI powered tools should be moving toward.

Built With

Share this project:

Updates