Skills Analysis & Extraction

Overview

SJM's Skills Analysis module uses advanced natural language processing to identify technical and soft skills from unstructured text. The system can:

• Extract skills from resumes, portfolios, job descriptions, and other text
• Normalize variant skill names (e.g., "React.js", "ReactJS", "React" → "React.js")
• Verify skills against a curated database
• Suggest similar or related skills when an exact match isn't found
• Identify job titles and technical roles

This functionality forms the foundation of SJM's matching capabilities, enabling precise alignment between freelancers and projects.

Key Components

Skills Extraction

The SkillsExtract class combines multiple techniques to identify skills in text:

• NLP-based extraction using NLTK, TF-IDF vectorization, and RAKE algorithms
• Pattern matching for common skill formats and variants
• Database verification against known skills
• Similarity matching to identify closely related skills

Skill Verification

Verify if a keyword represents a recognized skill or job title:

from sjm import SJM

client = SJM(api_key="your_api_key")

# Verify a specific skill
result = client.verify_skill("React.js")

# Check if the skill exists in the database
if result["data"]["exists"]:
  print(f"✅ The skill 'React.js' is verified in the database")
  if "skills" in result["data"]:
      print(f"Matching skills: {', '.join(result['data']['skills'])}")
else:
  print(f"❌ The skill 'React.js' is not verified")
  if result["data"]["similar_terms"]:
      print(f"Did you mean: {', '.join(result['data']['similar_terms'])}")

Skills Response Format

The skill verification API returns a comprehensive response with detailed information:

{
"status": "success",
"data": {
  "exists": true,        // Whether the skill exists in the database
  "similar_terms": [],   // Similar skills (if the skill doesn't exist)
  "type": "skill",       // Type: "skill" or "job_title" or null
  "matches": ["React.js"], // Exact matches found
  "skills": ["React.js"],  // Matching skills
  "job_titles": []       // Matching job titles (if any)
}
}

Resume Parsing

Extract structured information including skills from resumes using the parse endpoint:

from sjm import SJM

client = SJM(api_key="your_api_key")

# Parse a resume file
resume_data = client.parse_resume("resume.pdf")

# Extract skills and other information
if resume_data["status"] == "success":
  skills = resume_data["data"]["skills"]
  print(f"Extracted Skills: {', '.join(skills)}")
  
  # Check education and experience if available
  if resume_data["data"]["education"]:
      print(f"Education: {resume_data['data']['education']}")
  
  if resume_data["data"]["experience"]:
      print(f"Experience: {resume_data['data']['experience']}")
  
  # Check contact information
  if resume_data["data"]["contact"]:
      contact = resume_data["data"]["contact"]
      print(f"Email: {contact.get('email')}")
      print(f"Phone: {contact.get('phone')}")
      print(f"Location: {contact.get('location')}")

How It Works

Skills Database

SJM maintains a comprehensive database of skills grouped by category:

• Web Development: React.js, Node.js, TypeScript, Next.js, Vue.js, Angular, Django, Flask, PHP, Laravel
• Mobile Development: React Native, Flutter, Swift, Kotlin, iOS, Android, Mobile UI/UX, App Store Optimization
• Data Science: Python, R, Machine Learning, Data Analysis, SQL, Tableau, Power BI, Statistics
• Design: UI Design, UX Design, Figma, Adobe XD, Photoshop, Illustrator, After Effects

This database is used for verification and normalization of skills.

Skill Extraction Process

The skill extraction process follows these steps:

1. Preprocessing: Clean and normalize the input text
2. Tokenization: Break down the text into words and phrases using NLTK
3. Extraction: Apply RAKE algorithm to identify key phrases
4. Normalization: Convert identified skills to standard formats (e.g., "Reactjs" → "React.js")
5. Verification: Check skills against the database for validation

Skill Matching for Projects

When matching freelancers to projects, the system uses extracted skills to:

1. Identify required skills from project descriptions
2. Find freelancers with matching skills
3. Calculate a skill match score based on overlapping skills
4. Consider skill categories and related skills for comprehensive matching

Practical Applications

Finding the Perfect Match

Skills analysis is central to SJM's matching capability:

# Python
from sjm import SJM

client = SJM(api_key="your_api_key")

# Match freelancers to a project
matches = client.match(
  description="Build a modern web application with React and Node.js",
  required_skills=["React.js", "Node.js", "TypeScript"],
  budget_range=(5000, 10000),
  complexity="medium",
  timeline=30
)

# Display top matches with skill information
for match in matches["matches"][:3]:
  freelancer = match["freelancer"]
  print(f"Match: {freelancer['name']} ({freelancer['job_title']})")
  print(f"Skills: {', '.join(freelancer['skills'])}")
  print(f"Matching Skills: {match['matching_skills']}/{len(match['freelancer']['skills'])}")
  print(f"Score: {match['score']:.2f}")
  print("---")

Analyzing Project Requirements

Extract skills from project descriptions to understand technical needs:

# Python
from sjm import SJM
from sjm.utils import parse_skills_string

client = SJM(api_key="your_api_key")

# Sample project description
project_description = """
We're looking for an experienced full-stack developer to build a modern 
e-commerce platform. The candidate should have strong React.js and Node.js 
experience, with knowledge of RESTful APIs and database design. Experience 
with payment gateway integration is a plus. The project will use TypeScript 
throughout to ensure code quality.
"""

# Extract skills from the description
extracted_skills = []
for line in project_description.split('
'):
  skills = client.verify_skill(line)
  if skills["data"]["exists"]:
      extracted_skills.extend(skills["data"]["skills"])

print(f"Extracted skills: {', '.join(extracted_skills)}")

# Define required skills for the project
required_skills = ["React.js", "Node.js", "TypeScript", "MongoDB", "Payment Integration"]

# Match freelancers based on these skills
matches = client.match(
  description=project_description,
  required_skills=required_skills,
  budget_range=(5000, 15000),
  complexity="medium",
  timeline=60
)

Generating Technical Interviews

Use extracted skills to generate relevant interview questions:

# Python
from sjm import SJM

client = SJM(api_key="your_api_key")

# Extract skills from a freelancer's profile
freelancer_id = "f123"
required_skills = ["React.js", "Node.js", "TypeScript", "GraphQL"]

# Generate interview questions targeting these skills
interview = client.interview(
  freelancer_id=freelancer_id,
  project_description="Build a modern web application with React and Node.js",
  required_skills=required_skills,
  job_title="Full Stack Developer",
  mode="ai_questions"
)

# Display the generated questions
questions = interview["data"]["interview_data"]["questions"]
for i, q in enumerate(questions, 1):
  print(f"Q{i}: {q['text']}")

Integration with the SJM Ecosystem

Skills analysis integrates with all of SJM's core capabilities:

• Matching Engine: Uses verified skills for accurate freelancer-project matching
• Interview System: Generates skill-specific questions for technical assessment
• Resume Parsing: Extracts and validates skills from uploaded resumes