PrayasDas
Back to Projects

समर्थ्य

Web Development
June 2025 GitHub Live Demo

An AI-powered talent bridge that creates a self-sustaining ecosystem connecting students with job opportunities through intelligent profiling and matching mechanisms

Technologies

React Node.js TypeScript Supabase Clerk Auth TailwindCSS ShadCN AI/ML

Samarthya (समर्थ्य - “Capability/Competence”)

Overview

Samarthya is an AI-powered talent bridge that transforms how universities connect students with industry opportunities. By creating a self-sustaining ecosystem, it intelligently matches student profiles with job requirements while providing universities with data-driven insights to align curriculum with market demands.

This comprehensive platform addresses the critical gap between academic preparation and industry expectations, enabling universities to manage hundreds of technical colleges more effectively while empowering students with personalized career guidance and recruiters with intelligent candidate evaluation tools.

Tech Stack

  • Frontend: React with ShadCN and Tailwind CSS components for clean, responsive design
  • Backend: Node.js with API-driven architecture for efficient processing
  • Database: Supabase with Row-Level Security (RLS) policies for data privacy
  • Authentication: Clerk Authentication (development mode) for secure user management
  • AI Engine: Custom resume analysis and job matching algorithms
  • Deployment: Vercel for frontend, Railway for backend services

Features

For Students

  • AI-Driven Job Matching: Intelligent job recommendations based on comprehensive profile analysis
  • Application Tracking: Real-time progress monitoring across all job applications
  • Saved Jobs: Quick access to preferred opportunities with personalized bookmarking
  • AI Resume Analysis: Actionable feedback with resume scoring and layout improvements
  • Skill Gap Analysis: Personalized recommendations to enhance professional profiles
  • Career Path Visualization: Interactive roadmaps based on industry trends

For Recruiters

  • Rich Job Posting: Advanced text editor for detailed job descriptions and requirements
  • Integrated Hiring Pipeline: Real-time status updates and progress tracking
  • Smart Application Management: Direct candidate access with resume download options
  • AI-Powered Candidate Evaluation: Efficient suitability assessment and ranking tools
  • Bulk Communication: Automated messaging system for candidate updates

For Universities

  • Market Intelligence Dashboard: Real-time job market trends and industry insights
  • Curriculum Alignment: Data-driven recommendations for course updates and skill development
  • Student Success Tracking: Comprehensive analytics on placement outcomes and career progression
  • Industry Partnership Management: Tools for maintaining recruiter relationships

Architecture

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   React Client  │───▶│   Node.js API   │───▶│   Supabase DB   │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                       │                        │
         │              ┌─────────────────┐               │
         └─────────────▶│   AI Engine     │◀─────────────┘
                        │  (OpenAI GPT)   │
                        └─────────────────┘

Code Snippets

AI Job Matching Algorithm

const matchJobs = async (studentProfile, jobListings) => {
  const skillsVector = await generateSkillsEmbedding(studentProfile.skills);
  const matches = jobListings.map(job => ({
    job,
    compatibility: calculateCompatibility(skillsVector, job.requirements),
    skillGaps: identifySkillGaps(studentProfile.skills, job.requirements)
  }));
  
  return matches
    .filter(match => match.compatibility > 0.7)
    .sort((a, b) => b.compatibility - a.compatibility);
};

Resume Analysis Component

const ResumeAnalyzer = ({ resumeData }) => {
  const [analysis, setAnalysis] = useState(null);
  const [loading, setLoading] = useState(false);
  
  const analyzeResume = async () => {
    setLoading(true);
    try {
      const response = await fetch('/api/analyze-resume', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ resume: resumeData })
      });
      const result = await response.json();
      setAnalysis(result);
    } catch (error) {
      console.error('Analysis failed:', error);
    } finally {
      setLoading(false);
    }
  };
  
  return (
    <div className="resume-analyzer">
      <button onClick={analyzeResume} disabled={loading}>
        {loading ? 'Analyzing...' : 'Analyze Resume'}
      </button>
      {analysis && (
        <div className="analysis-results">
          <h3>Score: {analysis.score}/100</h3>
          <ul>
            {analysis.suggestions.map((suggestion, index) => (
              <li key={index}>{suggestion}</li>
            ))}
          </ul>
        </div>
      )}
    </div>
  );
};

Supabase RLS Policy

-- Enable RLS on student profiles
ALTER TABLE student_profiles ENABLE ROW LEVEL SECURITY;

-- Students can only view and edit their own profiles
CREATE POLICY "Students can manage own profile" ON student_profiles
    FOR ALL USING (auth.user_id() = user_id);

-- Recruiters can view all profiles but not edit
CREATE POLICY "Recruiters can view profiles" ON student_profiles
    FOR SELECT USING (auth.role() = 'recruiter');

How It Works

Student Onboarding → AI Profile Analysis → Job Matching → Application Tracking → Market Insights

  1. Profile Creation: Students upload resumes and complete comprehensive skill assessments
  2. AI Analysis: Advanced algorithms evaluate skills, experience, and career preferences using NLP
  3. Smart Matching: Jobs are ranked by compatibility scores and skill alignment with real-time updates
  4. Application Pipeline: Status tracking throughout the entire hiring process with automated notifications
  5. Data Aggregation: Anonymized insights feed back into university dashboards for curriculum optimization

Screenshots

Landing Page Landing Page

Login Screen Login Screen

AI Resume Analysis AI Resume Analysis AI Resume Analysis AI-powered resume analysis with actionable improvement suggestions

How to Run

Prerequisites

node --version  # v18.0.0 or higher
npm --version   # v8.0.0 or higher

Installation

# Clone the repository
git clone https://github.com/prayasdev/jobsamarth.git
cd samarthya

# Install dependencies
npm install

# Set up environment variables
cp .env.example .env.local
# Configure the following in .env.local:
# - SUPABASE_URL=your_supabase_url
# - SUPABASE_ANON_KEY=your_supabase_anon_key
# - CLERK_PUBLISHABLE_KEY=your_clerk_publishable_key
# - CLERK_SECRET_KEY=your_clerk_secret_key
# - OPENAI_API_KEY=your_openai_api_key

# Initialize database
npm run db:setup

# Start development server
npm run dev

Usage

# Run frontend (default: http://localhost:3000)
npm run dev:client

# Run backend API (default: http://localhost:8000)
npm run dev:server

# Run full stack
npm run dev:full

# Run tests
npm run test

# Build for production
npm run build

API Endpoints

GET    /api/jobs              # Fetch job listings
POST   /api/jobs              # Create new job posting
GET    /api/students          # Fetch student profiles
POST   /api/match             # Get job matches for student
POST   /api/analyze-resume    # Analyze resume with AI
GET    /api/analytics         # University dashboard data

Database Schema

-- Core tables
CREATE TABLE student_profiles (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  user_id UUID REFERENCES auth.users(id),
  skills TEXT[],
  experience JSONB,
  resume_url TEXT,
  created_at TIMESTAMP DEFAULT NOW()
);

CREATE TABLE job_postings (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  company_id UUID REFERENCES companies(id),
  title TEXT NOT NULL,
  requirements TEXT[],
  salary_range NUMRANGE,
  created_at TIMESTAMP DEFAULT NOW()
);

CREATE TABLE applications (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  student_id UUID REFERENCES student_profiles(id),
  job_id UUID REFERENCES job_postings(id),
  status TEXT DEFAULT 'applied',
  applied_at TIMESTAMP DEFAULT NOW()
);

Future Scope / Improvements

  • Advanced ML Models: Implement transformer-based models for better job-skill matching accuracy
  • Video Interview Integration: AI-powered preliminary screening with sentiment analysis and behavioral assessment
  • Blockchain Credentials: Immutable skill verification and certification system for academic achievements
  • Mobile Application: Native iOS/Android apps for on-the-go access with push notifications
  • Multi-language Support: Localization for regional universities and diverse job markets
  • Industry-Specific Modules: Specialized matching algorithms for healthcare, finance, tech, and manufacturing sectors
  • Virtual Career Fairs: Integrated video conferencing and networking features with AI-powered scheduling
  • Predictive Analytics: Career path forecasting based on market trends and economic indicators
  • Gamification: Achievement badges and progress tracking to increase student engagement
  • Advanced Analytics: Deeper insights with predictive modeling for placement success rates

Security

  • All API routes are protected with authentication middleware
  • Supabase RLS policies ensure data isolation between user types
  • Resume files are stored securely with access controls
  • Sensitive data is encrypted at rest and in transit

Tags: AI Machine Learning Job Matching Resume Analysis EdTech Talent Acquisition React Node.js Supabase University Management Career Development HR Tech

Built with ❤️ for bridging the gap between academia and industry

Have a wild project idea?

I'm open to collaboration!

Contact Me