Rinder

Swipe less. Live better. Rinder matches students with compatible roommates and housing, then helps them actually live together.

Comment

Inspiration

Rinder started with a problem we actually have.

We're university students in Fredericton, where finding housing can mean jumping between Facebook Marketplace, random listings and group chats, only to realize the "affordable" place you found is nowhere near a useful bus stop.

And finding the apartment is only half the problem.

You still have to figure out who you're actually going to live with.

So we started with one question:

What if finding a place and finding the right people happened together?

That became Rinder.

What it does

Rinder connects the different stages of shared living:

Find a Home → Find Your People → Actually Live Together

Students can discover housing using information that actually matters to them, including:

  • Rent
  • Available rooms
  • Utilities
  • Furnishing
  • Property type
  • Nearby transit
  • Walking time to bus stops

Then Rinder helps surface compatible roommates using factors like cleanliness, schedules, budget, social habits and living preferences.

We also built an AI housing assistant that lets users ask questions naturally instead of digging through every listing manually.

But we didn't want Rinder to stop once people matched.

That led us to Rinder Access.

A resident can press Unlock Door inside the Rinder web app and physically unlock our smart-lock prototype.

The request travels through:

Next.js → FastAPI → Serial → Arduino → Physical Lock

The LEDs show the current lock state, and after five seconds the system automatically locks again.

We also added a physical IR access method, giving the prototype both digital and physical control.

Built in Fredericton, Designed to Scale

Fredericton is our starting point because it is the housing market we actually understand.

But this isn't a Fredericton-only problem.

Students move to unfamiliar university towns every year and face the same disconnected process of finding housing, finding roommates and managing a shared home.

The city changes. The university changes. The listings and transit data change.

The platform stays the same.

That gives Rinder a path from:

UNB → Other Universities → Student Housing Operators → Shared-Living Communities

Start local. Prove it here. Then expand to other university communities facing the same problem.

Dual-Use Potential

While building Rinder Access, we realized the underlying problem goes beyond student housing:

Who belongs in a space, and what should they have access to?

For a student:

Find → Match → Move In → Access

For controlled or defence accommodation:

Assign → Authorize → Access → Monitor

The same foundation could be adapted for temporary personnel housing, training facilities, emergency-response accommodation, remote operational camps or other controlled accommodation.

Roommate matching becomes personnel-to-accommodation assignment.

Rinder Access becomes an identity and permission layer.

A student may need access to an apartment for the length of a lease. Personnel at a temporary facility may need access to an assigned building only for a specific training period or stay.

Different mission.

Same core problem: the right person, in the right place, with the right access.

Our Arduino lock is a proof of concept. A future implementation could integrate commercial smart locks, NFC readers or badge systems with temporary credentials, role-based permissions, automatic expiry, revocation and auditable access history.

How we built it

Rinder brings together several different technologies:

  • Next.js / React for the frontend
  • Firebase Authentication for users
  • Firestore for application and housing data
  • Python / FastAPI for backend services and hardware communication
  • Arduino UNO for Rinder Access
  • Servo, LEDs and IR receiver for the physical lock prototype
  • Serial communication between Python and Arduino
  • A structured Fredericton housing dataset
  • AI-assisted housing Q&A and data interpretation

The goal was not to add technology just because we could.

Every part had to make finding, sharing or managing a home easier.

The hardest part

The hardest part wasn't the swipe animation. It was making everything behind it actually trustworthy.

For roommate matching, we had to decide what compatibility really means. Rent and location matter, but so do cleanliness, schedules, social habits and expectations around a shared space.

Our AI taught us a similar lesson. Early on, it confidently described a value as "roughly 10%" when the actual answer was 35%.

That changed how we built the system.

For questions involving real calculations or factual lookups, Python computes the answer and the AI explains it. For real-world locations, we use geocoding and geographic data rather than asking the model to guess.

Then came the hardware.

An unlock request crosses:

React → Python → API → COM Port → Serial → Arduino C++ → Circuit → Servo

When something failed, the problem could be software, timing, serial communication, wiring, or literally one wire on the breadboard.

Sometimes it really was one wire.

At the same time, we had to keep the entire frontend visually consistent while features were constantly changing.

That became the real hackathon experience:

Build it. Break it. Figure out why. Fix it. Keep moving.

What we learned

The biggest thing we learned was that Rinder wasn't really about swiping.

Our original description was basically:

"Tinder, but for roommates."

The more we built, the less accurate that became.

The real problem is that finding housing, finding roommates and actually living together are treated as completely separate experiences.

We also learned that AI is much more useful when it knows what it should not be responsible for. Let deterministic code handle calculations and verified data. Let AI make that information easier for a person to understand.

And Rinder Access taught us how different software feels when an error affects something in the physical world instead of just a button on a screen.

What's next

The next step is taking Rinder beyond our hackathon dataset and validating it with real students, universities and housing operators.

We would like to explore:

  • Real-time housing data
  • Verified student profiles
  • Better roommate recommendations using match feedback
  • Temporary guest access
  • Individual access permissions
  • Automatic credential expiry
  • Entry history and audit logs
  • Maintenance reporting
  • Shared-home management
  • Integration with production access-control hardware

For the civilian side, we want to see whether the model can expand from Fredericton to other university communities.

For the dual-use side, the same foundation could be adapted around personnel assignment, controlled accommodation and auditable physical access.

Rinder

Rinder started because four students wanted to make finding a place in Fredericton suck less.

What we ended up building showed us that the problem was much bigger than one city.

At its core, Rinder connects:

People → Places → Compatibility → Permissions → Access

Civilian

Find → Match → Live → Access

Dual-Use

Assign → Authorize → Access → Monitor

Start local. Prove it here. Scale anywhere people need to live together.

Built With

Share this project:

Updates

Submission history