HiFive - HackDuke 2026

lowering the decision barrier on converting acquaintances to friends

Comment

Inspiration

We were inspired by Mr. Syed’s talk yesterday about decision fatigue, especially when it comes to everyday habits. It made us think about how difficult it has become to form new connections when everyone is busy and stuck in their own routines. We wanted to build something that makes those first interactions feel easier and more natural. The idea was to help people notice others they already see regularly, so conversations can grow out of familiar, everyday moments. By lowering the barrier to that first interaction, we hope to create small, consistent opportunities for connection that can turn into something meaningful over time.

What it does

HiFive is a mobile-first web app designed to help you connect with people you already see in your daily life. It passively detects when users are physically near each other and keeps track of how often their paths cross. Over time, these repeated encounters show up in a Suggestions feed, so instead of complete strangers, you start recognizing familiar faces. When the timing feels right, you can send a HiFive, which is a simple and low-pressure way to reach out. If both people accept, it opens up a real-time chat so you can start a conversation. The goal is to turn small shared moments into real connections.

How we built it

We built HiFive as a mobile-first web app with a focus on simplicity and responsiveness. The frontend uses React with Vite and Tailwind CSS, and we deployed it through GitHub Pages using a GitHub Actions CI/CD pipeline. On the backend, we used Node.js and Express hosted on DigitalOcean, connected to a managed PostgreSQL database. Real-time messaging is handled with Socket.IO, so users can chat instantly once they match. Authentication is powered by Auth0, with JWTs securing all protected API requests. To detect proximity, each client periodically shares its location using the browser’s Geolocation API. The backend then uses the Haversine formula to calculate distances between active users. When two users are within a defined radius, we log an encounter. Over time, these repeated encounters shape each user’s Suggestions feed, with more frequent encounters showing up more prominently. We also used Google Gemini through Antigravity as a coding assistant. It helped us move faster on things like setting up backend routes, connecting everything to the database, implementing messaging, and fixing UI issues on mobile. That speed gave us more time to focus on getting the full system working together instead of getting stuck on smaller pieces. We also used Google Gemini to help us with our documentation and README.md files.

Challenges we ran into

One of our biggest challenges was getting the proximity detection to work reliably outside of our local environment. It worked well during development, but once we deployed, we ran into issues with GPS permissions, HTTPS requirements, and differences between desktop and mobile browsers. We were not able to fully resolve that within the hackathon timeframe. We also ran into issues where AI-generated features worked locally but broke in production. A lot of the generated code assumed things like localhost URLs, simple environment setups, or numeric user IDs, which did not match our production setup with Auth0 and DigitalOcean. Getting everything aligned took more debugging than we expected.

Accomplishments that we're proud of

As a team of first-time hackers, we are really proud of how much we were able to build in such a short time. Most of us came in with limited full-stack experience, so a lot of this was learned as we went, from deploying a backend on DigitalOcean to integrating Auth0 and connecting everything to a real database. A big part of the process was figuring things out as we went, debugging issues we had not seen before, and making sure all the pieces actually worked together. Getting a fully deployed app running end to end, with authentication, real-time messaging, a database, and a CI/CD pipeline, in under 24 hours felt like a huge accomplishment.

What we learned

We learned pretty quickly that the gap between something working locally and working in production is bigger than it seems. Environment variables, authentication, database connections, and browser permissions all behaved differently once we deployed, and figuring that out under time pressure was difficult. We also got better at working as a team. We split up frontend and backend work, coordinated through a shared codebase, and made quick decisions about what was worth pursuing given the time constraints. On the technical side, many of us were using tools like Auth0, DigitalOcean, Socket.IO, PostgreSQL, and GitHub Actions for the first time. It gave us a much clearer picture of how a real production app comes together. We also learned how to work effectively with an AI coding assistant, which meant not just using what it generated, but understanding it well enough to adapt it when it did not quite fit our setup.

What's next for HiFive - HackDuke 2026

Our next step is making the core experience reliable. Right now, proximity detection is inconsistent across devices and browsers, so improving how we handle location updates and permissions is a top priority. We also want to give users more control over their visibility. Features like only sharing location at certain times or in certain places would make the app feel more comfortable to use. On the product side, we want to make starting conversations easier. Adding light context, like how often you have crossed paths, could help break the ice and make interactions feel more natural. Finally, we want to test with real users and iterate based on feedback. The idea only works if people actually enjoy using it in real life.

Share this project:

Updates