Roomies
Roomies is a roommate communication app designed to make the everyday logistics of living with other people a little less chaotic. Instead of talking about chores in a group chat, keeping a grocery list somewhere else, and remembering maintenance requests in your head, Roomies brings those things together in one place.
Role: UX/UI design & front-end development · Tools: Figma, React, Claude · Timeline: 2026
The idea
Living with roommates comes with a surprising amount of coordination. There are bills to split, chores to remember, household supplies that somehow always run out, maintenance issues to report, and schedules to keep track of. A lot of that communication ends up scattered across text messages, Venmo, notes apps, and conversations that are easy to forget.
I wanted to build something that treated those interactions as one connected experience. Rather than making another generic productivity app, I wanted Roomies to feel like a shared digital version of the home itself.
Audience: College students and people in their 20s who live with roommates and are navigating the everyday logistics of sharing a home.
The problem
Roommate coordination is scattered across too many places. Bills get forgotten or disputed, chores go undone because nobody knows who is responsible, shared items run out without anyone taking ownership, and household events live in individual calendars instead of somewhere everyone can see them.
The goal wasn't to solve every part of living with roommates. Instead, I focused on the small interactions that happen repeatedly and tend to create friction: asking someone for money, figuring out whose turn it is to clean something, remembering that you're out of toilet paper, reporting that something broke, or figuring out when everyone is actually going to be home.
Design process
I started with low-fidelity wireframes to figure out the basic structure of the application before thinking too much about the visual design. The main navigation became Home, Tasks, Calendar, and Profile. I wanted the most important household information to be accessible quickly without making the home screen feel like a dashboard full of widgets.
I wanted the visual language to feel warmer than a typical productivity or social media application. The color palette is intentionally soft and slightly muted, with the goal of making the interface feel more like a lived-in home than a task-management system. The typography and rounded interface elements reinforce that same feeling.
Designing around real roommate interactions
One of the things I focused on was how information is actually communicated between roommates. Instead of presenting bills as rows in a spreadsheet, for example, Roomies turns them into sentences that describe the interaction directly.
"Jenesis asks Michael for $25 for Internet."
This makes the information easier to understand at a glance and keeps the interface centered around people rather than transactions.
I applied the same idea to chores and household items. Instead of simply showing that a task exists, the interface communicates who is responsible for it and what has happened previously. The intention is to make accountability visible without making the application feel overly formal.
Key features
- Bills that let roommates specify exactly who owes what, with requests written as simple sentences rather than spreadsheet-style transactions.
- Chores that track responsibility and make it clear who is currently assigned to a task.
- Household items that keep track of shared supplies and who last restocked them.
- Shared calendar with month navigation, event times, and notes for keeping track of household plans.
- Maintenance requests for keeping track of things that need to be fixed around the home.
- Roommate finder for browsing available rooms or creating a listing when a roommate needs to be replaced.
Building the interface
After establishing the visual direction in Figma, I translated the designs into React. I kept the interface component-based so that recurring elements such as cards, navigation, buttons, task states, and category labels could be reused throughout the application.
I leveraged Claude throughout the development process to establish an efficient workflow, troubleshoot technical challenges, and refine code. Using Claude streamlined the development process by helping me iterate more quickly, explore solutions, and improve the overall implementation.
Current state
The current version is a functional front-end prototype running primarily on local state. The goal at this stage was to establish the interaction model and make sure the different pieces of the application worked together before adding the complexity of a full backend.
The next step is connecting the application to Supabase for authentication, persistent household data, and real multi-user interactions. This would allow multiple roommates to share the same household, create and assign tasks, update bills, and see changes in real time.
Additionally more robust features would be added to the application, such as real-time notifications, to alert roommates when a roommate has taken on/ completed a task. A more comprehensive roommate-finding feature would include additional information of what poster is looking for as well as an interactive map for finding places. Another potenital feature is a chat room for roommates to communicate directly on the app rather than on 3rd party applications.
What I learned
Roomies was an exercise in thinking about the difference between building a feature and building something that people would actually want to use. A roommate app can technically contain a calendar, task list, bill tracker, and messaging system, but simply putting those things together doesn't necessarily make the experience better. I wanted to focus on how these features could work together to address the everyday frustrations that come with living with roommates, rather than adding features simply because they were useful on their own. This meant thinking critically about what information roommates actually need, when they need it, and how to make those interactions feel simple rather than overwhelming. The project pushed me to consider the experience beyond functionality and think more intentionally about usability, communication, and the social dynamics of sharing a space.
View the GitHub repository