Command Palette

Search for a command to run...

GitHub
Blog
Previous

Matchwise- AI Powered Job Application Screening System

An AI-powered job application screening system designed to connect job candidates with the right positions based on skills, experience, and education match.

Demo Video

Source: https://youtu.be/EKeCuxTEGZ4

Introduction

Matchwise is an AI-powered job application screening system designed to connect job candidates with the right positions based on skills, experience, and education match. The system streamlines the recruitment process by automating candidate evaluation, shortlisting, and interview scheduling.

"Transform your recruitment process with intelligent AI that makes hiring faster, fairer, and more data-driven for both employers and job seekers."

Built with Python and Streamlit, Matchwise offers a clean, minimal interface that makes complex AI-powered matching accessible to HR teams. The system provides transparent scoring, automated shortlisting, and streamlined interview scheduling to revolutionize how organizations connect with top talent.

Core Features

Matchwise delivers a comprehensive suite of intelligent recruitment tools:

  • Smart Matching Algorithm - Uses AI to analyze and score candidate-job matches based on multiple criteria
  • Profile Management - View and manage job descriptions and candidate CVs with intuitive interfaces
  • Match Scoring - Transparent scoring system explains matching rationale with detailed breakdowns
  • Auto-Shortlisting - Automatically identifies high-scoring candidates (>59% match) for faster processing
  • Interview Scheduling - Schedule interviews with shortlisted candidates through a streamlined workflow
  • Email Templates - Generate professional interview invitation emails customized for each candidate
  • Data Visualization - Visual indicators make it easy to identify the best matches at a glance
  • Clipboard Integration - Copy generated emails with a single click for sending to candidates

Tech Stack

Matchwise is built with a carefully selected technology stack that prioritizes simplicity and performance:

Backend & Data

  • SQLite - Efficient local database with Python SQLite3 integration
  • Pandas & NumPy - Data manipulation and analysis
  • PyPDF2 - PDF processing for candidate CV files

Frontend & UI

  • Streamlit - Clean, responsive, minimal UI framework
  • Python 3.10+ - Modern Python for backend processing

AI & Processing

  • Simulated AI - Text analysis and semantic matching algorithms
  • NLP Techniques - Regular expressions and text processing for CV parsing
  • Optional OCR - pdf2image, pytesseract for enhanced document processing

Project Structure

Application Architecture

The system is organized into specialized agents that handle different aspects of the recruitment process:

CV Processing Agent

# cv_processing_agent.py - Extract information from candidate CVs
class CVProcessingAgent:
    def __init__(self):
        self.pdf_parser = PDFParser()
        self.text_processor = TextProcessor()
    
    def process_cv(self, cv_file_path):
        # Extract text from PDF
        raw_text = self.pdf_parser.extract_text(cv_file_path)
        
        # Process and structure the information
        candidate_data = {
            "personal_info": self.extract_personal_info(raw_text),
            "skills": self.extract_skills(raw_text),
            "experience": self.extract_experience(raw_text),
            "education": self.extract_education(raw_text)
        }
        
        return candidate_data
    
    def extract_skills(self, text):
        # Use NLP techniques to identify skills
        skills = self.text_processor.extract_skills(text)
        return skills

Job Description Agent

# job_description_agent.py - Process job requirements
class JobDescriptionAgent:
    def __init__(self):
        self.text_processor = TextProcessor()
    
    def process_job_description(self, job_text):
        job_requirements = {
            "required_skills": self.extract_required_skills(job_text),
            "experience_level": self.extract_experience_requirements(job_text),
            "education_requirements": self.extract_education_requirements(job_text),
            "responsibilities": self.extract_responsibilities(job_text)
        }
        
        return job_requirements
    
    def extract_required_skills(self, text):
        # Identify key skills mentioned in job description
        skills = self.text_processor.extract_job_skills(text)
        return skills

Matching Agent

# matching_agent.py - Calculate compatibility scores
class MatchingAgent:
    def __init__(self):
        self.scoring_model = ScoringModel()
    
    def calculate_match_score(self, candidate, job):
        scores = {
            "skills_match": self.calculate_skills_match(candidate, job),
            "experience_match": self.calculate_experience_match(candidate, job),
            "education_match": self.calculate_education_match(candidate, job)
        }
        
        # Weighted average of different factors
        total_score = (
            scores["skills_match"] * 0.5 +
            scores["experience_match"] * 0.3 +
            scores["education_match"] * 0.2
        )
        
        return {
            "total_score": total_score,
            "breakdown": scores,
            "confidence": self.calculate_confidence(scores)
        }
    
    def calculate_skills_match(self, candidate, job):
        candidate_skills = set(candidate["skills"])
        required_skills = set(job["required_skills"])
        
        if not required_skills:
            return 0.0
        
        matching_skills = candidate_skills.intersection(required_skills)
        return len(matching_skills) / len(required_skills) * 100

Initial Setup and Installation

Requirements

To run Matchwise locally, you'll need:

  • Python 3.10 or higher
  • Core dependencies: streamlit, pandas, numpy, PyPDF2
  • Optional: pdf2image, pytesseract (for enhanced OCR capabilities)

Installation Steps

  1. Clone the repository and navigate to the project directory
  2. Create a virtual environment
  3. Install dependencies from requirements.txt
  4. Run the application
# Create virtual environment
python -m venv matchwise-env
 
# Activate virtual environment
# Windows
matchwise-env\Scripts\activate
# macOS/Linux
source matchwise-env/bin/activate
 
# Install dependencies
pip install -r requirements.txt
 
# Run the application
streamlit run src/app.py

Database Initialization

On first run, the application will automatically:

  1. Create a data directory for the SQLite database
  2. Initialize database tables for jobs, candidates, matches, and interviews
  3. Generate sample job descriptions and candidate CVs for demo purposes

Application Workflow

Matchwise provides a comprehensive workflow across four main tabs:

1. Jobs Tab: Browse and Manage Job Descriptions

  • View job details including required skills, experience, and education
  • See detailed specifications for each position
  • Match candidates directly from the job details view

2. Candidates Tab: Browse and Manage Candidate CVs

  • View candidate details including extracted skills, experience, and education
  • Upload new candidate CVs or view existing ones
  • Inspect candidate qualifications at a glance

3. Matching Tab: Match Candidates to Jobs

  • Select jobs and view match scores across all candidates
  • See detailed breakdowns of skills, experience, and education matches
  • Shortlist promising candidates with a single click
  • Auto-shortlist feature for candidates with matches above 59%

4. Interviews Tab: Schedule and Manage Interviews

  • Schedule interviews with shortlisted candidates
  • Select date, time slot, and interview format
  • Generate professional email templates for candidates
  • Copy emails to clipboard with a single click

Advanced Features

Automated CV Analysis

The system automatically extracts key information from candidate CVs:

  • Contact information and personal details
  • Skills and technical competencies
  • Educational qualifications
  • Work experience and career history

Intelligent Job Description Processing

Job descriptions are analyzed to identify:

  • Required skills and competencies
  • Education requirements
  • Experience levels needed
  • Core responsibilities

Match Quality Assessment

The matching algorithm evaluates candidates based on:

  • Skills match percentage
  • Experience relevance and duration
  • Education appropriateness
  • Overall compatibility score

Deployment Options

Local Deployment

Follow the installation and usage instructions above for local deployment.

Cloud Deployment

The application can be deployed to various cloud platforms:

1. Streamlit Cloud

Free hosting for the Streamlit frontend:

  • Connect your GitHub repository
  • Point to src/app.py
  • Configure any necessary secrets

2. Render

Deploy the backend API:

  • Use the included run_production.py script
  • Set environment variables as specified in .env.example

3. Vercel

Serverless deployment:

  • Use the provided vercel.json configuration
  • Deploy with vercel CLI or through the Vercel dashboard

See DEPLOYMENT.md and VERCEL_DEPLOYMENT.md for detailed instructions.

Troubleshooting

Common Issues and Solutions

1. Missing Dependencies

Ensure you've installed all required packages:

pip install -r requirements.txt

2. Database Errors

If the database is corrupted, delete the data/matchwise.db file and restart:

# Windows
del /F /S /Q src\data\*.db
 
# macOS/Linux
rm src/data/matchwise.db

3. Port Issues

If port 8501 is already in use, Streamlit will automatically use another port.

4. Streamlit Configuration Errors

If you get a StreamlitSetPageConfigMustBeFirstCommandError, ensure that:

  • Only one file calls st.set_page_config()
  • The set_page_config() call is the first Streamlit command in the file
  • No other Streamlit imports or functions are called before it

5. CV Preview Issues

In deployed environments, CV file access may be limited:

  • When deploying to cloud services, the CV PDF files may not be accessible
  • The application will show a placeholder and extracted CV information instead
  • For local development, ensure CV files are in the expected directories

Getting Started

Ready to transform your recruitment process? Getting started with Matchwise is straightforward:

  1. Follow the installation instructions above
  2. Set up your Python environment and install dependencies
  3. Run the application locally or deploy to your preferred cloud platform
  4. Upload job descriptions and candidate CVs to start matching

"Matchwise empowers HR teams to make smarter hiring decisions through intelligent automation, transparent scoring, and streamlined workflows that save time while improving match quality."

Whether you're an HR professional looking to modernize your recruitment process, a startup building your first team, or an enterprise organization seeking to scale your hiring operations, Matchwise provides the intelligence and automation you need to connect with the right talent efficiently.

Conclusion

Matchwise represents a significant step forward in AI-powered recruitment technology. By combining intelligent matching algorithms with an intuitive user interface, it bridges the gap between complex AI capabilities and practical HR needs.

The system's transparent scoring methodology, automated workflows, and comprehensive candidate evaluation tools make it an invaluable asset for organizations of all sizes. As the job market continues to evolve, tools like Matchwise will become increasingly essential for connecting the right people with the right opportunities.

This project demonstrates the potential for AI to enhance human decision-making in recruitment, providing data-driven insights while maintaining the human touch that's crucial for successful hiring decisions.