A peer-to-peer academic marketplace where university students earn from their knowledge.

CampusHustle connects students who need help — tutoring, study materials, exam prep — with fellow students who have the skills to provide it. Instead of hiring expensive professional tutors, students learn from peers who recently mastered the same courses, understand the exact curriculum, and are motivated to build a reputation and earn income while doing it.

This isn't just a tutoring app. It's an academic creator economy: students monetizing their knowledge through live mentorship, study notes, and AI-assisted learning — all built and secured with a university-verified trust layer.

• Problem & Vision
• Core Features (MVP)
• Future Roadmap
• Tech Stack
• System Architecture
• Getting Started
• Environment Variables
• Project Structure
• Security Considerations
• Contributing
• License

University students possess valuable, up-to-date academic knowledge, but have no structured way to monetize it while balancing their own studies. Meanwhile, other students need affordable, relatable help — from someone who took the exact same course, not a generic tutoring service.

CampusHustle solves both problems at once: a verified, university-scoped marketplace where students can tutor, sell notes, and get paid for what they already know — while learners get fast, affordable, peer-relevant help.

• University email–verified signup and login
• JWT-based authentication with hashed passwords
• Student and Tutor profiles with skills, subjects, department, and year

• Structured skill/subject tagging (searchable, not free text)
• Filter by subject, price, rating, and department
• Public tutor profiles showing rating, sessions completed, and verification status

• Tutors set fixed weekly availability slots
• Students request a slot; tutors accept or decline
• Booking status tracking: pending → confirmed → completed / cancelled

• Real-time 1:1 messaging (Socket.io), unlocked after a connection or booking is accepted
• Free-tier chat for coordination and quick questions
• Optional, consent-based, logged sharing of contact details within a chat thread

• Tutors upload study materials as PDFs — or photograph physical notes directly
• Photographed notes are converted to text via OCR (Tesseract.js) and packaged as downloadable PDFs
• Preview pages, course tagging, pricing, and purchase via integrated payment gateway

• Uploaded notes are chunked and embedded on upload
• Students can ask questions answered only from that tutor's uploaded material — no hallucinated answers from outside sources
• Built on a lightweight retrieval pipeline: no dedicated vector database required

• Multi-dimensional reviews: knowledge, communication, punctuality
• Report and block functionality to protect users, especially around in-chat contact sharing

• In-app alerts for new booking requests, accepted bookings, new messages, and note purchases

The following are intentionally out of MVP scope but represent the platform's long-term direction:

• Subscription plans for recurring access to a tutor's content
• Group sessions and fixed-price crash courses
• Gamified tutor levels (Bronze → Diamond) and badges
• Live whiteboard, screen sharing, and collaborative code editor
• Recorded session playback
• Native mobile app (Flutter)
• Advanced analytics dashboards for tutors
• Automated ID verification pipeline (OCR + face-match confidence scoring with human-in-the-loop review)

All third-party services are used strictly within their free tiers, in line with this project's scope as a learning and graduation project.

┌─────────────┐        ┌──────────────┐        ┌───────────────┐
│   React App  │ <────> │  Express API │ <────> │   MongoDB      │
│ (Vite +      │  REST/ │  + Socket.io │        │   Atlas        │
│  Tailwind)   │  WS    │              │        │                │
└─────────────┘        └──────┬───────┘        └───────────────┘
                               │
                 ┌─────────────┼─────────────┐
                 │             │             │
          ┌──────▼─────┐ ┌────▼────┐  ┌─────▼──────┐
          │ Cloudinary │ │  Gemini  │  │   Chapa     │
          │ (files)    │ │ (AI/RAG) │  │ (payments)  │
          └────────────┘ └─────────┘  └────────────┘

Notes upload → RAG pipeline flow:

Upload (PDF or photo) 
   → [if photo] OCR text extraction (Tesseract.js)
   → Text chunking
   → Embedding generation (Gemini)
   → Stored in MongoDB with vector + metadata
   → Student question → embed query → cosine similarity search
   → Top matching chunks → Gemini generates grounded answer

• Node.js (v18+)
• npm or yarn
• A MongoDB Atlas account (free tier)
• API keys: Gemini, Cloudinary, Chapa (as applicable)

# Clone the repository
git clone https://github.com/dan-seng/campus-hustle.git
cd campus-hustle

# Install server dependencies
cd server
npm install

# Install client dependencies
cd ../client
npm install

# Start the backend (from /server)
npm run dev

# Start the frontend (from /client)
npm run dev

The frontend will run on http://localhost:5173 and the backend on http://localhost:5000 by default.

Create a .env file in /server with the following:

PORT=5000
MONGODB_URI=your_mongodb_atlas_connection_string
JWT_SECRET=your_jwt_secret
GEMINI_API_KEY=your_gemini_api_key
CLOUDINARY_CLOUD_NAME=your_cloudinary_name
CLOUDINARY_API_KEY=your_cloudinary_key
CLOUDINARY_API_SECRET=your_cloudinary_secret
CHAPA_SECRET_KEY=your_chapa_key
EMAIL_USER=your_gmail_address
EMAIL_PASS=your_gmail_app_password

Never commit .env files. A .env.example is provided as a template.

campus-hustle/
├── client/                # React frontend
│   ├── src/
│   │   ├── components/
│   │   ├── pages/
│   │   ├── hooks/
│   │   └── services/
│   └── package.json
├── server/                 # Express backend
│   ├── controllers/
│   ├── models/
│   ├── routes/
│   ├── middleware/
│   ├── services/           # RAG pipeline, OCR, payments
│   └── package.json
├── docs/                   # SRS, architecture notes, diagrams
└── README.md

Given this project's emphasis on secure design:

• Passwords are hashed with bcrypt; raw passwords are never stored or logged
• JWTs are short-lived, with refresh token rotation
• Contact information shared in chat is consent-based and logged for audit purposes
• Rate limiting is applied to booking requests and message sends to prevent spam and abuse
• Uploaded files are validated and scanned before processing
• Role-based access control restricts actions by Student, Tutor, and Admin roles
• Sensitive future features (e.g., ID verification) are designed with data minimization in mind — processed rather than permanently stored where possible

Built by Team

1. Daniel Gidey - CTC-056-26
2. Chara Desalegn - CTC-2160-26
3. Efrata Endalkachew - CTC-7063-26
4. Dani Jafer - CTC-214-26
5. Bemnet Sisay - CTC-2274-26
6. Dlayehu Desalegn

This project is currently unlicensed pending a decision on its future direction. All rights reserved by the author until a license is added.