Profaganda

Race to guess your professors through their reviews!

Comment 1

Inspiration

We wanted to create a product that was both entertaining, as well as somewhat informational. Drawing from our shared experience as students dealing with professor reviews and the uncertainty of choosing classes, we saw an opportunity to gamify the professor review ecosystem while creating an engaging party game that friends could enjoy together.

What it does

Profaganda is a multiplayer party game where friends can set up and join each other to compete in 2 exciting game modes:

  1. Mode 1 - Professor Guessing: Players are shown a real RateMyProfessor review and must guess which professor from Cornell the review is about from multiple choice options.

  2. Mode 2 - Real vs. Fake: Players are presented with a review for a specific professor and must determine whether the review is genuine (from RateMyProfessor/CUReviews) or fake (AI-generated).

The game features real-time multiplayer functionality with live scoring, leaderboards, and party management.

How we built it

Technology Stack

  • Frontend: Next.js w/ React, TypeScript, and Tailwind CSS for a modern, responsive UI
  • Backend: Node.js with Express server handling WebSocket connections via Socket.IO for real-time multiplayer gameplay
  • Database: MongoDB Atlas for building and storing professor data, real reviews, and fake reviews.
  • AI Integration: Google Gemini API for generating realistic fake professor reviews and normalizing/sanitizing existing reviews
  • Deployment: Vercel for frontend and API serverless functions, with a dedicated HTTPS server for WebSocket connections; Oracle Cloud hosting for Node server.

Architecture

  1. Web Application (apps/web/): Next.js frontend with game phases (Home, Lobby, Round, Leaderboard, End)
  2. API Layer (apps/api/): Vercel serverless functions handling game data and professor/review queries
  3. Socket Server (server.js): Real-time WebSocket server managing game state, player connections, and live scoring
  4. Data Pipeline (apps/pipeline/): Automated systems for ingesting professor data from multiple sources and generating AI reviews
  5. Shared Packages: Common database operations and TypeScript type definitions

Real-time Features

  • WebSocket-based multiplayer with Socket.IO
  • Live score updates and player tracking
  • Party management with unique lobby codes
  • Automatic round timing and game phase transitions
  • Real-time answer submission and validation

Challenges we ran into

We ran into significant issues with cloud hosting for the database, serverless functions for the API layer, and the Node.js backend server. Specifically:

  • Database Connectivity: MongoDB Atlas connection pooling and timeout issues in serverless environments
  • Serverless Cold Starts: Vercel function initialization delays affecting game responsiveness
  • WebSocket Deployment: Hosting real-time Socket.IO server separately from the main application due to serverless limitations
  • SSL/TLS Configuration: Setting up HTTPS certificates for secure WebSocket connections
  • Data Pipeline Complexity: Coordinating multiple data sources and AI generation while maintaining data quality
  • State Management: Synchronizing game state between WebSocket server and API endpoints

Accomplishments that we're proud of

We're proud of being able to work well as a team in spite of all the challenges we faced, especially with 3/4 teammates having this be their first hackathon in particular. Our key achievements include:

  • Successful Integration: Seamlessly combining real professor data with AI-generated content for an engaging game experience
  • Real-time Multiplayer: Building a robust WebSocket-based system that handles multiple concurrent games
  • Data Quality: Creating a sophisticated pipeline that processes and sanitizes real professor review data while generating believable fake reviews
  • User Experience: Designing an intuitive, responsive interface that works across devices
  • Technical Architecture: Implementing a scalable monorepo structure with shared packages and clean separation of concerns
  • AI Implementation: Successfully leveraging Google Gemini for both content generation and data sanitization

What we learned

We learned about the value of teamwork and being able to rely on one another and trust one another. We also learned about the ability to have fun and take everything lightly while maintaining focus on technical excellence. Specific technical learnings include:

  • Microservices Complexity: Managing communication between multiple services and handling distributed state
  • Real-time Systems: The intricacies of WebSocket management, connection handling, and state synchronization
  • AI Integration: Prompt engineering and managing API rate limits for content generation
  • Data Pipeline Engineering: Building reliable systems for data ingestion, processing, and quality assurance
  • Serverless Architecture: Understanding the trade-offs and limitations of serverless deployment models
  • Team Collaboration: Using monorepo structures and shared packages for efficient collaborative development

What's next for Profaganda

Keep it up and running! A possible roadmap includes:

  • Expanded Content: Adding more universities beyond Cornell and incorporating additional review sources
  • Enhanced Game Modes: Introducing new game types like "Guess the Rating" or "Match the Course"
  • Social Features: Friend systems, persistent user profiles, and tournament modes
  • Mobile App: Native mobile applications for iOS and Android
  • Performance Optimization: Improved caching, database optimization, and reduced latency

Built With

Share this project:

Updates