ML-Powered Campus Sharing Economy Platform
A production-grade, real-time marketplace where verified college students rent, sell, give, recover lost items, and fulfill community requests — powered by intelligent recommendations and event-driven architecture.

Live App: https://sharenet-web-1.onrender.com

Note for Judges & Evaluators: Gmail (@gmail.com) sign-up is temporarily enabled for evaluation and testing purposes. This allows judges to register and explore the full platform without needing a .edu or .ac.in email. This access will be disabled after the evaluation period. In production, only verified college email domains are permitted.

Every semester across Indian and global campuses:

• Students spend thousands on items they only need for weeks (projectors, books, lab equipment)
• Lost belongings go unclaimed because there's no centralized, trusted recovery system
• There is no verified, college-scoped platform — generic marketplaces (OLX, Facebook groups) have zero identity verification, no trust systems, and no campus boundaries
• Students who need specific items have no way to broadcast that demand to peers who might have them

Result: Wasted money, wasted resources, broken trust, and a fragmented campus experience.

ShareNet transforms every campus into a self-sustaining circular economy. It combines a three-mode marketplace, a verified lost & found system, a community wanted board, and ML-powered recommendations — all scoped by college domain and backed by a behavioral trust engine.

Unlike generic platforms, ShareNet enforces trust at the infrastructure level: OTP-verified campus emails, domain-scoped item visibility, behavioral trust scores, and structured transaction lifecycles with dispute resolution.

ShareNet is not a single shared marketplace. It is a multi-tenant platform where every college operates as an independent, isolated ecosystem — all from a single deployment.

┌─────────────────────────────────────────────────────────────────┐
│                     ShareNet (Single Deployment)                │
│                                                                 │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐              │
│  │  IIIT       │  │  IIT        │  │  NIT        │   ...100+    │
│  │  Lucknow    │  │  Bombay     │  │  Trichy     │   colleges   │
│  │             │  │             │  │             │              │
│  │ Items       │  │ Items       │  │ Items       │              │
│  │ Users       │  │ Users       │  │ Users       │              │
│  │ Lost&Found  │  │ Lost&Found  │  │ Lost&Found  │              │
│  │ Wanted      │  │ Wanted      │  │ Wanted      │              │
│  │ Trust Scores│  │ Trust Scores│  │ Trust Scores│              │
│  └─────────────┘  └─────────────┘  └─────────────┘              │
│       ↕ Zero data leakage between campuses ↕                    │
└─────────────────────────────────────────────────────────────────┘

How it works:

Why this matters: A student at IIIT Lucknow sees only items, lost posts, and wanted requests from IIIT Lucknow. This keeps the experience hyperlocal, relevant, and trustworthy — exactly how a campus community should work. And yet, the entire system runs on a single deployment, making it operationally simple and cost-effective to scale to hundreds of colleges.

100+ Indian college domains supported out of the box — IIITs, IITs, NITs, and more. New domains are auto-detected or can be added via GitHub Issues.

ShareNet's recommendation system goes beyond simple filtering. It implements a multi-signal scoring model that learns from user behavior:

Score = CategoryAffinity(3) + TrustSignal(1) + ModeRelevance(1) + RecencyBoost(2)

Items are scored, ranked, and the top 6 are surfaced as "Picked for You" on the browse page — each with a visual "Recommended" badge. Recommended items are deduplicated from the main feed to prevent redundancy.

Why this matters: Users see relevant items immediately instead of scrolling through hundreds of listings. This drives engagement and faster transactions.

Every item listing supports one of three modes:

Instant Claim (for Give mode): Owners can enable a queue-based system where users join a claim queue instantly without owner approval. The system enforces maxClaimers limits — once the queue is full, the item shows "Fully Claimed." This eliminates manual review overhead for high-demand free items.

Counter-Offer System: Owners can respond to requests with modified terms. Full negotiation history is preserved, creating a transparent bargaining trail.

This isn't a simple "post and hope" system. ShareNet implements a structured verification pipeline:

Report → Claim Submitted → Verification Questions Sent → Answers Reviewed
  → Claim Verified → Chat Opens → Meetup Coordinated → Resolved

• Verification Questions: When posting a lost item, the owner sets custom security questions (e.g., "What sticker is on the back?"). Only the real owner would know the answers.
• Claim Review: The poster reviews answers before approving. False claims are rejected.
• Dedicated Chat: Once verified, a rich chat channel opens with image sharing, GPS location, and meetup proposals.
• Resolution Tracking: Posts are marked as resolved, providing campus-wide recovery statistics.

Why this matters: On most campuses, lost items are posted in WhatsApp groups with zero verification. Anyone can claim anything. ShareNet adds accountability.

A reverse-marketplace where demand creates supply:

1. Student posts what they need (title, description, budget, urgency level)
2. Other students browse wanted posts and make offers (with price, description, photos)
3. The requester reviews competing offers and accepts the best one
4. A private chat channel opens for coordination

Urgency Levels: Low → Medium → High → Urgent — visually color-coded so the community can prioritize.

Why this matters: Traditional marketplaces only work when supply is already listed. The wanted board captures latent demand and activates supply that wouldn't otherwise be listed.

ShareNet uses Socket.IO for a fully event-driven real-time layer:

All messages are persisted in MongoDB — users see full history when they reopen a chat.

Trust isn't a static rating — it's a dynamic, behavior-driven metric that reflects real transaction outcomes:

• Every user starts at 50 / 100
• Trust scores are displayed on profiles, item cards, and within the ML recommendation engine (high-trust owners get priority)
• The system creates a self-regulating community — bad actors are deprioritized organically

Every transaction follows a structured, auditable state machine:

REQUESTED → ACCEPTED → AGREEMENT_PROPOSED → ACTIVE → RETURN_PENDING → COMPLETED
                                                          ↘ DISPUTED

Why this matters: Unstructured sharing (WhatsApp, word of mouth) has no accountability. ShareNet's lifecycle creates a paper trail that protects both parties.

Enter Email → Detect College Domain → Send 6-Digit OTP (Resend API) → Verify → Register

• Supports 100+ Indian college domains (IIITs, IITs, NITs, and more)
• Dynamically detects valid .edu / .ac.in / .edu.in patterns
• Items are automatically scoped to the user's collegeDomain — students only see items from their own campus
• New colleges can be added via GitHub Issues

┌──────────────────────────────────────────────────────────────────┐
│                         FRONTEND                                 │
│  React 19 · Vite · Tailwind CSS · Zustand · React Router 7       │
│  Socket.IO Client · Axios · Lucide Icons · date-fns              │
└───────────────────────┬──────────────────────────────────────────┘
                        │  REST API (Axios) + WebSocket (Socket.IO)
┌───────────────────────▼──────────────────────────────────────────┐
│                         BACKEND                                  │
│  Express.js · JWT + Refresh Token Auth · Multer (file uploads)   │
│  Socket.IO Server · node-cron (reminders) · Resend (OTP email)   │
│  ML Recommendation Engine · Trust Score Engine                   │
└───────────┬───────────────────────┬──────────────────────────────┘
            │                       │
   ┌────────▼────────┐    ┌────────▼────────┐
   │   MongoDB       │    │   Cloudinary    │
   │   Atlas         │    │   (Media CDN)   │
   └─────────────────┘    └─────────────────┘

ShareNet-Web/
├── ShareNet/                          # Frontend (React + Vite)
│   ├── src/
│   │   ├── components/
│   │   │   ├── ui/                    # Design system: Button, Card, Modal, Badge, Avatar, TrustScore, Loader
│   │   │   ├── layout/               # Navbar, Layout wrapper
│   │   │   ├── items/                 # ItemCard, ItemFilters, ItemForm, ClaimQueue, CounterOfferModal
│   │   │   ├── transactions/          # TransactionCard, AgreementForm, NegotiationHistory
│   │   │   ├── chat/                  # ChatBox (transaction-scoped real-time chat)
│   │   │   └── wanted/               # OfferChatBox, OfferCard
│   │   ├── pages/                     # 18+ route-level page components
│   │   ├── stores/                    # Zustand state management (auth, items, transactions, notifications, etc.)
│   │   ├── hooks/                     # Custom hooks (useClaimChat, useOfferChat — Socket.IO integration)
│   │   └── lib/                       # Axios instance (interceptors, refresh logic), Socket.IO client
│   └── public/                        # Static assets, SPA redirect rules
│
└── professional-backend-structure/    # Backend (Express + MongoDB)
    └── src/
        ├── controllers/               # 10 controller files — all business logic
        ├── models/                    # 12 Mongoose schemas with indexes and virtuals
        ├── routes/                    # 10 Express routers — RESTful API design
        ├── middlewares/               # JWT verification, Multer file upload
        ├── services/                  # Reminder cron service (daily automated checks)
        ├── utils/                     # ApiError, ApiResponse, Cloudinary upload, OTP email, college registry
        ├── socket.js                  # Socket.IO event handlers (chat, typing, notifications)
        ├── app.js                     # Express app with CORS, security middleware
        └── index.js                   # Server entry point

cd professional-backend-structure
npm install
cp .env.example .env    # Fill in MongoDB URI, JWT secrets, Cloudinary, Resend keys
mkdir -p public/temp
npm run dev              # Runs on http://localhost:8000

cd ShareNet
npm install
cp .env.example .env    # Set VITE_API_URL=http://localhost:8000/api/v1
npm run dev              # Runs on http://localhost:5173

ShareNet is open source. We welcome contributions from the community.

1. Fork the repository
2. Create a feature branch (git checkout -b feature/your-feature)
3. Commit changes (git commit -m 'Add your feature')
4. Push to branch (git push origin feature/your-feature)
5. Open a Pull Request

Have a college that's not supported? Open an issue and we'll add the domain.

MIT

Built for students. Driven by trust. Scaled for every campus.
Share more. Spend less. Build community.