Live Demo

https://roomofourown.us/

Inspiration

The cancellation of Grace Hopper Celebration 2026 made the need for a lasting community feel especially urgent. When a gathering that means so much to women in computing disappears, where do those conversations, connections, and opportunities go?

This project grew out of our frustration with an environment where support for DEI feels increasingly precarious and women's rights are once again treated as up for debate. We wanted to create a perpetual space for women in tech: somewhere to find support, share knowledge, and build together year-round, beyond a single conference or an institution's changing priorities.

Virginia Woolf wrote about the importance of having a room of one's own: the space and independence to create. We wanted to bring that idea into technology. What does a room of your own look like when what you want to write is code?

For us, it looks like a place where you can ask questions, find a mentor, meet someone who shares your interests, and start building before you have everything figured out. It also means having access to the tools you need, even if you cannot buy them yourself.

Inspired by Girls Hoo Hack and the community at UVA, we built A Room of Our Own, a women-centered, gender-inclusive space for people in tech to create opportunities together.

If we're not given a seat at the table, we'll build our own room.

What it does

A Room of Our Own connects the people, conversations, ideas, and resources that help a community grow.

  • Rooms: Create a talk, workshop, coworking session, or ongoing chatroom about a computer science topic. Meet in person, virtually, or both. Members can RSVP, chat, and request to help run a room as a collaborator, with host approval.
  • Connections: Discover potential mentors and collaborators through Hinge-inspired profiles with photos, personal prompts, skills, and interests. Send likes, form mutual connections, and start a direct conversation. Clicking someone's name or avatar opens their profile.
  • Build together: Post project ideas, search for topics and skills, and find people to build with. Hardware projects can suggest relevant items from the community's sharing shelf and link to learning resources.
  • Share resources: Lend or give away electronics, tools, computing equipment, and materials. Members can search listings and manage borrowing requests, returns, and pickups. Sharing makes projects more accessible while encouraging people to reuse what the community already has.

Interest-based recommendations help members discover relevant people, rooms, and resources. A community board brings those opportunities together, while reporting, blocking, and visibility controls give members more control over their experience.

How we built it

We built the frontend with React, TypeScript, and Vite, using React Router for navigation, TanStack Query for server data, and React Hook Form with Zod for form validation. Our backend uses Django and Django REST Framework to manage accounts, profiles, rooms, connections, messages, projects, and resource requests.

The app uses session authentication and CSRF protection, with backend permission checks for ownership, private meeting links, and member interactions. Local development uses SQLite; the deployment configuration supports PostgreSQL and S3 media storage. Docker packages the frontend and backend, with Gunicorn and WhiteNoise serving the application.

We also added a Tiger Data integration for resource-sharing activity. When enabled on a compatible database, it stores events in a TimescaleDB hypertable and uses a continuous aggregate to summarize daily activity. The sharing shelf displays activity counters to make reuse visible.

Recommendations currently use interests, skills, and keyword matching. Room conversations refresh through polling and support replies, editing, and deletion.

Visually, we wanted the site to feel personal and inviting. Purple, door imagery, Polaroid-style photos, and a vintage Macintosh on the About page connect the experience to the idea of having a space to create.

Challenges we ran into

One challenge was connecting several features without making the app feel like several unrelated products. We gave each area a clear purpose: connections introduce people, rooms bring them into conversations, projects give them something to build, and resource sharing helps them get started.

We also had to refine layouts for laptop use. Moving navigation, search, and filters into sidebars made browsing easier while preserving the expressive profile cards at the center of Connections.

The technical challenge was keeping interactions consistent across the interface and backend: collaborator approval, borrowing status changes, profile visibility, and chat permissions all needed clear rules. Animation accessibility was another consideration, including respecting reduced-motion preferences.

Accomplishments that we're proud of

We're proud of turning a literary inspiration into a working community experience with a recognizable visual identity.

The strongest part is how the features connect. Someone can discover a room, meet a potential collaborator, find a project, and borrow equipment to help build it. Resource sharing makes sustainability part of participating in the community, with an emphasis on reuse rather than buying something new for every idea.

We're also proud of the details that make participation more approachable: personal profile prompts, searchable discovery, clickable member identities, host-approved collaboration, and room conversations that continue beyond a scheduled event.

What we learned

We learned that building a community platform involves much more than adding ways to communicate. People need to understand where to go, what they can do there, and how to return to the relationships they have started.

Working across React and Django reinforced the importance of keeping form validation, API behavior, permissions, and database changes aligned. We also learned how much small design decisions matter: readable text, aligned fields, clear navigation, and predictable links can make an ambitious product feel approachable.

Most of all, we learned to prioritize depth. Improving the conversations and connections already in the app is more valuable right now than adding another entire social feed.

What's next for A Room of Our Own

Our immediate priorities are more reliable incoming DM updates, notifications for important interactions, and a persistent unread inbox so people can easily return to conversations.

We also want to test the experience with students and campus organizations, improve recommendations through their feedback, and better understand how the sharing shelf helps people access equipment and reuse materials. Over time, we hope to support more campus communities and community-led events.

Our goal is for every woman in tech to have access to a room of her own, and the opportunity to open its doors to others.

More technical details for the MLH Gemini API and Tiger Data Tracks

How Gemini works here

The project suggester is retrieval-augmented generation over the shared resource catalog. The flow when a member hits "Suggest a project" and submits a build goal:

  1. The frontend posts the goal to POST /api/suggest-project/, handled by backend/apps/resources/suggest.py.
  2. Retrieval: up to 60 catalog listings are embedded with Gemini's gemini-embedding-001 model using the RETRIEVAL_DOCUMENT task type, and the goal plus the member's interests are embedded as a RETRIEVAL_QUERY. Cosine similarity ranks the listings and the top 12 move on.
  3. Caching: listing embeddings are cached in the server process, keyed by a hash of each listing's text, so only new or edited listings are re-embedded.
  4. Generation: one function, gemini_suggest(), calls gemini-3.8-flash with a prompt that contains only the retrieved listings and asks for strict JSON: title, description, difficulty, steps, and part ids chosen from the retrieved set. The response shape is validated before it is used, which keeps the suggestion grounded in parts that actually exist.
  5. Posting: one click turns the result into a project idea through the normal projects endpoint.

Key handling and failure modes:

  • The API key comes from the GEMINI_API_KEY environment variable only and travels in the x-goog-api-key request header, never in URLs, logs, or responses. Usage is billed by Google to the account that owns the key; the models are configurable through the GEMINI_MODEL and GEMINI_EMBED_MODEL environment variables.
  • Every failure maps to a short non-secret reason code (invalid-key, key-or-api-disabled, model-not-found, quota, network), and the endpoint falls back to keyword matching, so the feature responds even with no key, no quota, or no network path to Google.
  • Both the embedding call and the generation call are each isolated in a single small function, so another provider (for example Amazon Bedrock) can be swapped in without touching the endpoint.

How Tiger Cloud works here

Tiger Cloud is a managed PostgreSQL service, and it hosts the database this app uses in production and in shared team development. The app talks to it as plain Postgres through Django's standard postgresql backend; nothing in the app code depends on Tiger-specific extensions.

  • Local by default: with no database settings, Django uses a local SQLite file, so the app runs with zero setup.
  • Shared dev database: the team's backend/.env (never committed) points local Django at one shared Tiger Cloud database, so everyone develops against the same data. That is why running python manage.py migrate after pulling schema changes matters for the whole team.
  • In production: the ECS task definition sets DB_HOST, DB_NAME, DB_USER, and DB_PORT from Terraform variables, and DB_PASSWORD is injected from AWS Secrets Manager, so no credential is ever in the image or the repo. backend/config/settings.py switches from SQLite to Postgres whenever DB_HOST is present.
  • Migrations in deploys: the container entrypoint (deploy/entrypoint.sh) runs python manage.py migrate on every boot, then starts Gunicorn, so a deploy always brings the database schema up to date.
  • Outside the repo: the instance's region and plan are not in the codebase; Terraform carries only the connection settings as variables.

Tech stack

  • Frontend: React 19, TypeScript, Vite, React Router, TanStack Query, React Hook Form, and Zod.
  • Backend: Django 5.2 and Django REST Framework, with session authentication and CSRF protection.
  • Data and media: SQLite for local development; PostgreSQL (hosted on Tiger Cloud) and S3 storage in production.
  • AI (optional): Google Gemini API. gemini-embedding-001 embeds goals and resources for retrieval, and gemini-3.8-flash generates suggestions.
  • Production serving: Docker, Gunicorn, and WhiteNoise.

Recommendations use profile interests, skills, and keyword matching. The project suggester uses the Gemini API when a key is configured and falls back to keyword matching without one, so the app runs fully with no AI key.

Deployment

  • CI/CD: GitHub Actions (.github/workflows/deploy.yml) runs the backend tests, builds the Docker image, pushes it to Amazon ECR, and rolls the ECS service on every push to main.
  • Compute: Amazon ECS on Fargate behind an Application Load Balancer. The React frontend is built into the same image and served through Django and WhiteNoise.
  • Data: PostgreSQL hosted on Tiger Cloud; media files on S3.
  • Secrets: Database credentials, the Django secret key, and the Gemini API key live in AWS Secrets Manager and are injected into the container at launch. The Gemini key syncs from a GitHub repository secret during deploys.
  • Infrastructure as code: The AWS stack is defined in Terraform under deploy/terraform: load balancer, service, roles, and secrets.
  • Domain: DNS managed in Route 53, with the registered domain pointed at the hosted zone.

Built With

Share this project:

Updates

Submission history