diff --git a/CV_PARSING_FLOW.md b/CV_PARSING_FLOW.md
new file mode 100644
index 0000000..c3890d3
--- /dev/null
+++ b/CV_PARSING_FLOW.md
@@ -0,0 +1,711 @@
+# CV Parsing Complete Flow - MeWannaJob System
+
+## System Architecture Overview
+
+The CV parsing system is a **client-side + server-side** hybrid architecture that extracts candidate information from resumes and matches them to jobs using machine learning.
+
+---
+
+## Complete Flow Diagram
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                         FRONTEND: index.html                                │
+│                     (Resume Upload & Parsing Page)                          │
+└──────────────────────────────────────┬──────────────────────────────────────┘
+                                       │
+                                       ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                      SCRIPT.JS: Main Parser Orchestration                   │
+│                                                                             │
+│  parseResume() function:                                                    │
+│  1. User clicks "Analyze & Find Jobs" button                                │
+│  2. Get file from input (PDF, DOCX, or TXT)                                 │
+└──────────────────────────────────────┬──────────────────────────────────────┘
+                                       │
+                ┌──────────────────────┼──────────────────────┐
+                │                      │                      │
+                ▼                      ▼                      ▼
+        ┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+        │  extractPdfText │    │ extractDocxText │    │   file.text()   │
+        │  (using PDF.js) │    │ (using Mammoth) │    │   (for TXT)     │
+        └────────┬────────┘    └────────┬────────┘    └────────┬────────┘
+                 │                      │                      │
+                 └──────────────────────┼──────────────────────┘
+                                       │
+                                       ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│            restoreWordBoundaries() - Cleanup Extracted Text                │
+│  - Splits camelCase words (extractedName → extracted Name)                 │
+│  - Separates numbers from letters (2020jobs → 2020 jobs)                   │
+│  - Fixes double-spacing issues                                             │
+└──────────────────────────────────────┬──────────────────────────────────────┘
+                                       │
+                      ┌────────────────┼────────────────┐
+                      │                │                │
+                      ▼                ▼                ▼
+        ┌──────────────────────┐  ┌──────────────────┐  ┌───────────────────┐
+        │  extractSkills()     │  │ extractName()    │  │ extractEducation()│
+        │  (Uses SKILL_DICT)   │  │                  │  │ (Uses RegEx)      │
+        └──────────┬───────────┘  └────────┬─────────┘  └─────────┬─────────┘
+                   │                       │                     │
+                   │                       │                     │
+        ┌──────────▼───────────┐           │                     │
+        │ Comprehensive Skill  │           │                     │
+        │ Dictionary Lookup    │           │                     │
+        │ (100+ skills with    │           │                     │
+        │  aliases & patterns) │           │                     │
+        └──────────┬───────────┘           │                     │
+                   │                       │                     │
+                   │  Returns:             │  Returns:           │  Returns:
+                   │  ["Python",           │  "John Doe"         │  "Master" or
+                   │   "JavaScript", ...]  │                     │  "Bachelor" or
+                   │                       │                     │  "Associate"
+                   │                       │                     │
+                   └───────────┬───────────┴─────────────────────┘
+                               │
+                ┌──────────────┼──────────────┬────────────────────────┐
+                │              │              │                        │
+                ▼              ▼              ▼                        ▼
+        ┌─────────────┐ ┌────────────┐ ┌──────────────┐ ┌───────────────────┐
+        │extractTitle │ │extractCerts│ │extractLocation    estimateYears()  │
+        │             │ │            │ │(Classifies by)    (Parses dates)  │
+        │ Finds: Data │ │ Detects:   │ │ - City, State     - Explicit:     │
+        │ Engineer,   │ │ - AWS Cert │ │ - ZIP code        "5 years"       │
+        │ Developer   │ │ - PMP      │ │ - Country hints   - Date ranges:  │
+        │             │ │            │ │ - Indian states   Jan 2020 - Now  │
+        └─────────────┘ └────────────┘ └──────────────┘ └───────────────────┘
+                                │
+                ┌───────────────┼───────────────┬──────────────────────┐
+                │               │               │                      │
+                ▼               ▼               ▼                      ▼
+        ┌────────────────┐ ┌──────────────┐ ┌──────────────┐ ┌───────────────┐
+        │extractIndustries│ extractAchievements  extractCerts   (Already done)
+        │                │ (Uses Patterns)    │              │
+        │ Detects:       │ - Dean's List      │              │
+        │ - Education    │ - Scholar          │              │
+        │ - Software     │ - Awards/Prizes    │              │
+        │ - Healthcare   │ - Competitions     │              │
+        └────────────────┘ └──────────────────┘ └──────────────┘ └───────────────┘
+                │
+                │ All extracted fields combined into:
+                ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                   BUILD resumeJSON Object (client-side)                     │
+│                                                                              │
+│  resumeJSON = {                                                             │
+│    inputs: [{                                                               │
+│      candidate_id: "CAND-1734000000",                                       │
+│      full_name: "John Doe",                                                 │
+│      location: "San Diego, CA 92101",                                       │
+│      education_level: "Master",                                             │
+│      years_experience: 8,                                                   │
+│      skills: ["Python", "JavaScript", "AWS"],                               │
+│      certifications: ["AWS Solutions Architect"],                           │
+│      current_title: "Software Engineer",                                    │
+│      industries: ["Software"],                                              │
+│      achievements: ["Dean's List", "Published Paper"]                       │
+│    }],                                                                      │
+│    password: "craig123"                                                     │
+│  }                                                                          │
+└──────────────────────────────────────┬──────────────────────────────────────┘
+                                       │
+                                       ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│              sendJSON() - Send to Backend (Netlify Function)                │
+│                                                                              │
+│  Endpoint: /.netlify/functions/classify-cv                                  │
+│  Method: POST                                                               │
+│  Body: resumeJSON object (JSON)                                             │
+│                                                                              │
+│  Purpose: Backend ML model computes competitive_score                       │
+└──────────────────────────────────────┬──────────────────────────────────────┘
+                                       │
+                                       ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│          BACKEND: Netlify Function (classify-cv/classify-cv.mjs)            │
+│                                                                              │
+│  1. Receives resumeJSON                                                     │
+│  2. Runs Supervised ML Model (Logistic Regression)                         │
+│  3. Computes: competitive_score (likelihood of being hired)                │
+│  4. Returns: { predictions: [{ competitive_score: 0.87 }] }                │
+└──────────────────────────────────────┬──────────────────────────────────────┘
+                                       │
+                                       ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│          SCRIPT.JS: Update Resume with Backend Score                       │
+│                                                                              │
+│  response = { predictions: [{ competitive_score: 0.87 }] }                │
+│  resumeJSON.inputs[0].competitive_score = 0.87                             │
+└──────────────────────────────────────┬──────────────────────────────────────┘
+                                       │
+                                       ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│        displayParsedResume() - Show Results on index.html                   │
+│                                                                              │
+│  Shows parsed fields in preview card:                                       │
+│  Location: San Diego, CA 92101                                              │
+│  Education: Master                                                          │
+│  Years Exp: 8                                                               │
+│  Title: Software Engineer                                                   │
+│  Skills: Python, JavaScript, AWS, ...                                       │
+│  Competitive Score: 0.87 (87%)                                              │
+└──────────────────────────────────────┬──────────────────────────────────────┘
+                                       │
+                                       ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│              goToJobsPage() - Navigate to Job Matching                      │
+│                                                                              │
+│  1. localStorage.setItem("parsedResume", JSON.stringify(resumeJSON))        │
+│  2. window.location.href = "jobs.html"                                      │
+└──────────────────────────────────────┬──────────────────────────────────────┘
+                                       │
+                                       ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                   JOBS.HTML + JOBS.JS - Job Matching Page                  │
+│                                                                              │
+│  loadResume() function on page load:                                        │
+│  1. Retrieve resumeJSON from localStorage                                   │
+│  2. Normalize skills using SKILL_DICT (alias matching)                     │
+│  3. Store resume data in window.resumeData                                 │
+└──────────────────────────────────────┬──────────────────────────────────────┘
+                                       │
+                                       ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│        Fetch Job Data - Load from Netlify Function (get-jobs)               │
+│                                                                              │
+│  Endpoint: /.netlify/functions/get-jobs                                     │
+│  Returns: Array of job postings from database                               │
+│  Schema: {                                                                  │
+│    job_title, company_name, job_location, job_industries,                  │
+│    job_seniority_level, job_employment_type, job_posted_date,              │
+│    job_description, salary, ...                                            │
+│  }                                                                          │
+└──────────────────────────────────────┬──────────────────────────────────────┘
+                                       │
+                                       ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│              populateFilters() - Build Filter Dropdowns                     │
+│                                                                              │
+│  From job data, extract unique values:                                      │
+│  - Companies: Apple, Google, Microsoft, etc.                                │
+│  - Locations: San Diego, New York, Remote, etc.                             │
+│  - Industries: Software, Finance, Healthcare, etc.                          │
+│  - Seniority: Junior, Senior, Lead, Executive, etc.                         │
+│  - Employment Type: Full-time, Part-time, Contract, etc.                    │
+│                                                                              │
+│  Populate select elements: #filterCompany, #filterLocation, etc.            │
+└──────────────────────────────────────┬──────────────────────────────────────┘
+                                       │
+                                       ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│            filterJobs() - Main Matching & Filtering Logic                   │
+│                                                                              │
+│  For each job posting:                                                      │
+│                                                                              │
+│  1. SKILL MATCHING                                                          │
+│     - Extract skills from job description                                   │
+│     - Compare with candidate's skills                                       │
+│     - Compute skill_overlap_score (0-1)                                    │
+│     - Example: 8 of 12 required skills = 0.67                              │
+│                                                                              │
+│  2. RELEVANCE SCORING (Text-based)                                         │
+│     - TF-IDF of resume vs job description                                  │
+│     - Keyword matching (years exp, education, title)                       │
+│     - Location proximity scoring                                            │
+│     - Result: relevance_score (0-1)                                        │
+│                                                                              │
+│  3. COMBINED MATCHING SCORE                                                │
+│     final_score = 0.6 * skill_overlap + 0.4 * relevance_score             │
+│                                                                              │
+│  4. APPLY USER FILTERS                                                      │
+│     - Company filter                                                        │
+│     - Location filter                                                       │
+│     - Industry filter                                                       │
+│     - Seniority level filter                                                │
+│     - Employment type filter                                                │
+│     - Global search (title/company/keywords)                                │
+│     - Date filter (posted after date)                                       │
+│                                                                              │
+│  5. SORT RESULTS                                                            │
+│     - By relevance (descending)                                             │
+│     - By match score (high/low)                                             │
+│     - By date (newest first)                                                │
+│     - By salary (highest first)                                             │
+│                                                                              │
+│  6. RETURN FILTERED & SORTED JOBS                                          │
+└──────────────────────────────────────┬──────────────────────────────────────┘
+                                       │
+                                       ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│            renderJobs() - Display Matched Jobs on Page                      │
+│                                                                              │
+│  For each matched job, create card showing:                                 │
+│  - Job Title & Company                                                      │
+│  - Match Score (visual bar: 0-100%)                                         │
+│  - Required Skills (with icons)                                             │
+│  - Candidate's Matching Skills (highlighted in green)                       │
+│  - Missing Skills (highlighted in red)                                      │
+│  - Location & Seniority                                                     │
+│  - Employment Type                                                          │
+│  - Salary & Posted Date                                                     │
+│  - View Details button                                                      │
+│  - Apply button                                                             │
+│                                                                              │
+│  Result Count Badge: "150 found" (total matches)                            │
+└──────────────────────────────────────┬──────────────────────────────────────┘
+                                       │
+                                       ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│          User Interaction - View & Filter Results                           │
+│                                                                              │
+│  User can:                                                                   │
+│  1. Click job card to view full job description                             │
+│  2. Apply filters and search in real-time                                   │
+│  3. Sort by different criteria                                              │
+│  4. Click "New Resume" to upload different resume                           │
+│  5. Click "Apply" (external link to job posting)                            │
+│                                                                              │
+│  Sticky sidebar shows:                                                      │
+│  - Candidate profile summary                                                │
+│  - Competitive score                                                        │
+│  - Inferred job type preferences                                            │
+│  - Skills breakdown                                                         │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Detailed Component Breakdown
+
+### 1. **index.html** - Resume Upload Page
+- **Purpose**: Entry point for users
+- **Key Elements**:
+  - File input for resume (PDF, DOCX, TXT)
+  - "Analyze & Find Jobs" button
+  - Status messages display
+  - Preview section (hidden initially, shows parsed resume)
+  - Script includes:
+    - `skill_dict.js` - Comprehensive skill dictionary
+    - `education_text_handler.js` - Education level classifier
+    - `achievementClassifier.js` - Achievement/award parser
+    - `locationClassifier.js` - Location extractor
+    - `script.js` - Main parsing logic
+
+---
+
+### 2. **script.js** - Main Parser Orchestration
+
+#### **Text Extraction Functions**:
+```javascript
+extractPdfText(file)
+  ├─ Uses: PDF.js library
+  ├─ Method: Converts PDF to text with line break detection
+  └─ Returns: Cleaned text string
+
+extractDocxText(file)
+  ├─ Uses: Mammoth.js library
+  └─ Returns: Raw text from DOCX
+
+file.text()
+  └─ For plain TXT files (native JS API)
+```
+
+#### **Text Cleanup**:
+```javascript
+restoreWordBoundaries(text)
+  ├─ Splits camelCase: extractedName → extracted Name
+  ├─ Separates numbers: 2020job → 2020 job
+  ├─ Fixes spacing issues
+  └─ Returns: Cleaned text
+```
+
+#### **Field Extraction Functions**:
+
+| Function | Input | Output | Method |
+|----------|-------|--------|--------|
+| `extractSkills(text)` | Resume text | String[] of skills | SKILL_DICT alias lookup |
+| `extractName(text)` | Resume text | String name | Regex: `[A-Z][a-z]+ [A-Z][a-z]+` |
+| `extractEducation(text)` | Resume text | "Doctorate"\|"Master"\|"Bachelor"\|"Associate" | Keyword detection (using education_text_handler.js) |
+| `estimateYears(text)` | Resume text | Number | Date range parsing + explicit "X years" mentions |
+| `extractLocation(text)` | Resume text | String location | City/State/Country detection (using locationClassifier.js) |
+| `extractTitle(text)` | Resume text | String role | Keyword matching against predefined roles |
+| `extractCerts(text)` | Resume text | String[] | Regex patterns for known certifications |
+| `extractIndustries(text)` | Resume text | String[] | Keyword-based industry detection |
+| `extractAchievements(text)` | Resume text | String[] | Pattern matching for honors, awards, publications |
+
+---
+
+### 3. **model/data/skill_dict.js** - Comprehensive Skill Dictionary
+
+**Structure**:
+```javascript
+const SKILL_DICT = {
+  "Canonical Skill Name": ["alias1", "alias2", "pattern", ...],
+  "Python": ["python", "python3", "cpython", "pypy"],
+  "SQL": ["\bsql\b", "mysql", "postgresql", "postgres", "oracle", "sqlite"],
+  "AWS": ["aws", "amazon web services", "ec2", "s3", "lambda"],
+  // ... ~100 more skills
+};
+```
+
+**Features**:
+- **100+ canonical skills** across categories:
+  - Programming Languages (Python, Java, C++, R, SQL)
+  - Frameworks (React, Django, Spring, Flask)
+  - Cloud Platforms (AWS, Azure, GCP)
+  - Data Tools (TensorFlow, PyTorch, Spark, Hadoop)
+  - DevOps (Docker, Kubernetes, Jenkins, GitLab CI)
+  - Databases (MongoDB, PostgreSQL, Redis, Elasticsearch)
+  - BI Tools (Tableau, Power BI, Looker, Qlik)
+  - Design (Figma, Sketch, Adobe XD)
+  - Project Management (Agile, Scrum, PMP)
+
+- **Alias Matching**: Single skill can match multiple keywords
+  - "React" matches: react, reactjs, react.js
+  - "Scikit-Learn" matches: sklearn, scikit-learn, scikit
+  - "SQL" matches: sql, mysql, postgresql, oracle, sqlite (with word boundaries)
+
+---
+
+### 4. **model/parsing/education_text_handler.js** - Education Classifier
+
+**Detects** (in priority order):
+1. **Doctorate** (~15 patterns):
+   - PhD/Ph.D., Doctorate, DPhil
+   - JD (Law), DO/DDS/DMS/DNP (Medical)
+   - PharmD, Psy.D.
+
+2. **Master** (~10 patterns):
+   - Master's, MS/M.S., MA/M.A., MSC, MBA
+   - M.Eng, M.Ed, MSN, Nurse Practitioner
+   - Negative: Excludes "headmaster", "master plan", "master electrician"
+
+3. **Bachelor** (~10 patterns):
+   - Bachelor's, BS/B.S., BA/B.A., BSC, BFA
+   - B.Eng., BE (Engineering)
+   - BSN (Nursing)
+
+4. **Associate** (~5 patterns):
+   - Associate's, AA, AS, AAS
+
+5. **Default**: Returns education level found, or "Unknown"
+
+---
+
+### 5. **model/parsing/locationClassifier.js** - Location Extractor
+
+**Detection Strategy** (priority order):
+
+1. **City, State, ZIP** (Most specific)
+   - Pattern: `City, ST 12345`
+   - Example: `San Diego, CA 92101`
+
+2. **US State Names** (50 states + DC)
+   - Matches full names: "California", "Texas"
+   - Returns with ZIP if found nearby
+
+3. **Indian States** (36 states/UTs)
+   - Matches: "Maharashtra", "Karnataka", "Delhi"
+   - Returns with PIN (6-digit code) if found
+
+4. **US ZIP codes** (5 or 9 digits)
+   - Pattern: `12345` or `12345-6789`
+
+5. **India PIN codes** (6 digits, with optional space)
+   - Pattern: `123456` or `123 456`
+
+6. **Country Detection**
+   - Looks for hints: USA, UK, Canada, Australia, India, etc.
+
+**Output Example**:
+- Resume has: "San Diego, California 92101"
+- Returns: `"San Diego, CA 92101"`
+
+---
+
+### 6. **model/parsing/achievementClassifier.js** - Achievement Extractor
+
+**Detects** (multiple patterns):
+
+1. **Academic Honors**:
+   - Dean's List, Chancellor's List
+   - Summa Cum Laude, Magna Cum Laude, Cum Laude
+
+2. **Scholarships & Fellowships**:
+   - Scholarship, Fellowship mentions
+
+3. **Publications & Awards**:
+   - Best Paper, Best Poster
+   - Publication Award
+
+4. **Competitions & Contests**:
+   - Hackathon, Case Competition, Datathon
+   - CodeFest, ICPC, ACM, Olympiad
+   - Science Fair, Robotics
+   - Kaggle, LeetCode, Codeforces
+
+5. **Rankings & Placements**:
+   - 1st Place, Runner-up, Finalist
+   - Top X% performers
+
+**Output Example**:
+```javascript
+[
+  "Dean's List",
+  "Won first place in case competition 2023",
+  "Hackathon finalist at TechCrunch Disrupt"
+]
+```
+
+---
+
+### 7. **resumeJSON Structure** (Client-side Object)
+
+```javascript
+{
+  "inputs": [
+    {
+      "candidate_id": "CAND-1734000000",           // Unique ID (timestamp-based)
+      "full_name": "John Doe",                     // From regex extraction
+      "location": "San Diego, CA 92101",           // From locationClassifier
+      "education_level": "Master",                 // From education_text_handler
+      "years_experience": 8,                       // From date range parsing
+      "skills": ["Python", "AWS", "Docker"],       // From SKILL_DICT matching
+      "certifications": ["AWS Solutions Architect"], // From extractCerts()
+      "current_title": "Software Engineer",        // From role keywords
+      "industries": ["Software"],                  // From industry keywords
+      "achievements": [                            // From achievementClassifier
+        "Dean's List",
+        "Published research paper"
+      ]
+    }
+  ],
+  "password": "craig123"                          // Backend auth
+}
+```
+
+---
+
+### 8. **Backend Communication** - Netlify Functions
+
+#### **sendJSON() - POST to classify-cv**
+```
+Endpoint: /.netlify/functions/classify-cv
+Method: POST
+Body: resumeJSON (all parsed fields)
+Response: {
+  "predictions": [{
+    "competitive_score": 0.87  // 0-1 range
+  }]
+}
+```
+
+**Backend Processing**:
+1. Receives resumeJSON
+2. Loads trained Logistic Regression model (from applicant-evaluator-training.py)
+3. Vectorizes candidate features using HashingTF
+4. Computes probability of candidate being hired
+5. Returns competitive_score
+
+---
+
+### 9. **jobs.html** - Job Matching Dashboard
+
+**Layout**:
+```
+┌─────────────────────────────────────────────────────────┐
+│ Navbar: MeWannaJob | New Resume button                  │
+├────────┬────────────────────────────────────────────────┤
+│        │                                                │
+│ Sidebar│        Main Content Area                       │
+│ (3col) │ (9col)                                         │
+│        │                                                │
+│        │  Search & Filter Toolbar                       │
+│ Profile│  ┌─────────────────────────────────────────┐   │
+│ Summary│  │ [Search Box] [Search Button]            │   │
+│        │  │ [Company▼] [Location▼] [Industry▼]      │   │
+│        │  │ [Seniority▼] [Type▼] [Sort▼]            │   │
+│        │  │ [Date Filter] [Apply Filters] [Reset]   │   │
+│        │  └─────────────────────────────────────────┘   │
+│        │                                                │
+│        │  Job Results (Infinite scroll / paginated)     │
+│ Job    │  ┌──────────────────────────────────────┐      │
+│ Type   │  │ Job Card 1: Engineer @ Google        │      │
+│ Insights│ │ Match: ████████░░ 82%                │      │
+│        │  │ Skills: Python✓ Java✓ SQL✗ Docker✓ │       │
+│        │  └──────────────────────────────────────┘      │
+│        │                                                │
+│        │  ┌──────────────────────────────────────┐      │
+│        │  │ Job Card 2: Data Scientist @ Meta    │      │
+│        │  │ Match: █████░░░░░░ 51%               │      │
+│        │  │ Skills: Python✓ R✗ TensorFlow✓...   │      │
+│        │  └──────────────────────────────────────┘      │
+│        │                                                │
+└────────┴────────────────────────────────────────────────┘
+```
+
+---
+
+### 10. **jobs.js** - Job Matching Engine
+
+#### **Main Functions**:
+
+```javascript
+loadResume()
+  ├─ Retrieve from localStorage
+  ├─ Parse resumeJSON structure
+  ├─ Normalize skills using SKILL_DICT aliases
+  ├─ Display profile summary in sidebar
+  ├─ Fetch jobs from get-jobs endpoint
+  └─ Call populateFilters() and filterJobs()
+
+populateFilters()
+  ├─ Extract unique companies, locations, industries, seniority, types
+  └─ Populate <select> dropdowns with unique values
+
+filterJobs()
+  ├─ For each job:
+  │  ├─ Extract required skills from description
+  │  ├─ Compute skill_overlap_score
+  │  ├─ Compute relevance_score (TF-IDF, keywords, location)
+  │  ├─ Compute final_score = 0.6 * skills + 0.4 * relevance
+  │  └─ Apply user filters (company, location, industry, etc.)
+  │
+  ├─ Sort results (relevance, score, date, salary)
+  └─ Call renderJobs()
+
+renderJobs(jobsFiltered)
+  ├─ Clear previous results
+  ├─ For each job, create card:
+  │  ├─ Title, Company, Match Score bar
+  │  ├─ Skills section (matching highlighted green, missing red)
+  │  ├─ Location, Seniority, Employment Type
+  │  ├─ Salary & Posted Date
+  │  └─ View Details & Apply buttons
+  └─ Update result count badge
+
+clearFilters()
+  └─ Reset all filters and re-run filterJobs()
+
+inferJobTypes(resume)
+  └─ Analyze candidate's skills/experience to suggest job types
+```
+
+---
+
+### 11. **Matching Algorithm** - Core Logic
+
+```javascript
+// SKILL MATCHING
+skill_overlap_score = (matching_skills / required_skills) * 1.0
+// Example: Candidate has 8 of 12 required skills = 0.67
+
+// RELEVANCE SCORING (Text-based)
+relevance_score = computed from:
+  ├─ TF-IDF similarity (resume vs job description)
+  ├─ Years experience match (candidate vs required)
+  ├─ Education level match (candidate vs required)
+  ├─ Location proximity (exact match = 1.0)
+  ├─ Title relevance (role matching)
+  └─ Industry alignment
+
+// COMBINED SCORE
+final_score = 0.6 * skill_overlap_score + 0.4 * relevance_score
+// Result: 0-1 (displayed as 0-100% match)
+
+// FILTERING (After scoring)
+show job if:
+  ├─ Company matches filter OR "any" selected
+  ├─ Location matches filter OR "any" selected
+  ├─ Industry matches filter OR "any" selected
+  ├─ Seniority matches filter OR "any" selected
+  ├─ Employment type matches filter OR "any" selected
+  ├─ Global search matches title/company/keywords
+  ├─ Posted date >= selected date filter
+  └─ (final_score > threshold)
+```
+
+---
+
+## Data Flow Summary
+
+```
+Resume File (PDF/DOCX/TXT)
+        │
+        ▼
+Text Extraction + Cleanup
+        │
+        ├─► extractSkills (SKILL_DICT)
+        ├─► extractEducation (regex + patterns)
+        ├─► estimateYears (date parsing)
+        ├─► extractLocation (city/state/country)
+        ├─► extractTitle (role keywords)
+        ├─► extractName (regex)
+        ├─► extractCerts (pattern matching)
+        ├─► extractIndustries (keywords)
+        └─► extractAchievements (awards/honors)
+        │
+        ▼
+resumeJSON Object (client-side)
+        │
+        ├─► Display on index.html (preview)
+        │
+        ├─► Send to Backend (classify-cv)
+        │   └─► Returns competitive_score
+        │
+        └─► Store in localStorage
+            │
+            ▼
+        jobs.html loads page
+            │
+            ├─► Retrieve from localStorage
+            ├─► Normalize skills (aliases)
+            ├─► Display in sidebar (profile summary)
+            │
+            ├─► Fetch jobs (get-jobs endpoint)
+            │
+            └─► For each job:
+                ├─► Score: skill_overlap + relevance
+                ├─► Filter: apply user filters
+                ├─► Sort: by relevance/score/date/salary
+                └─► Display: rendered job cards
+
+```
+
+---
+
+## Key Technologies Used
+
+| Component | Technology | Purpose |
+|-----------|-----------|---------|
+| PDF parsing | PDF.js | Extract text from PDF resumes |
+| DOCX parsing | Mammoth.js | Extract text from Word documents |
+| Education detection | Regex + keyword patterns | Classify education level |
+| Location detection | Regex + geography database | Extract city/state/country |
+| Skill matching | SKILL_DICT (100+ skills) | Match skills with aliases |
+| Achievement detection | Pattern matching | Detect awards, honors, competitions |
+| Backend ML | Logistic Regression (PySpark) | Compute competitive score |
+| Frontend framework | Bootstrap 5 | UI/UX layout and components |
+| Job matching | TF-IDF + skill overlap | Score and rank job matches |
+| Storage | localStorage | Persist parsed resume (client-side) |
+
+---
+
+## Summary
+
+The CV parsing system follows this complete pipeline:
+
+1. **User uploads resume** (index.html)
+2. **Client-side parsing** (script.js) extracts all fields using specialized extractors
+3. **Backend scoring** (Netlify function) computes competitive_score using ML
+4. **Resume preview** displays parsed fields on index.html
+5. **User navigates to jobs.html** with parsed resume in localStorage
+6. **Job matching engine** (jobs.js) scores and filters jobs based on:
+   - Skill overlap (using SKILL_DICT)
+   - Relevance scoring (TF-IDF, keywords, location)
+   - User-selected filters
+7. **Job cards rendered** with match scores, skill highlights, and filtering options
+8. **User can explore, filter, and apply** to matched jobs
+
+This architecture separates concerns (parsing vs matching vs UI) while leveraging ML for intelligent candidate evaluation.
diff --git a/databricks/candidate-clustering-localunspervised.py b/databricks/candidate-clustering-localunspervised.py
new file mode 100644
index 0000000..b33ec8e
--- /dev/null
+++ b/databricks/candidate-clustering-localunspervised.py
@@ -0,0 +1,544 @@
+"""
+K-Means Clustering for Candidate Segmentation
+Local version using scikit-learn - Uses real resume data
+"""
+
+import pandas as pd
+import numpy as np
+import os
+import re
+from pathlib import Path
+from sklearn.cluster import KMeans
+from sklearn.preprocessing import StandardScaler, OneHotEncoder
+from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
+from sklearn.metrics import silhouette_score
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# PDF and DOCX parsing
+try:
+    import PyPDF2
+    import docx
+except ImportError:
+    print("Installing required libraries...")
+    import subprocess
+    subprocess.check_call(['pip', 'install', 'PyPDF2', 'python-docx'])
+    import PyPDF2
+    import docx
+
+print("=" * 80)
+print("CANDIDATE CLUSTERING - REAL RESUME DATA")
+print("=" * 80)
+
+# ============================================================================
+# 1. PARSE REAL RESUMES FROM DATASET
+# ============================================================================
+
+def extract_text_from_pdf(pdf_path):
+    """Extract text from PDF file"""
+    try:
+        with open(pdf_path, 'rb') as file:
+            reader = PyPDF2.PdfReader(file)
+            text = ''
+            for page in reader.pages:
+                text += page.extract_text() + '\n'
+        return text
+    except Exception as e:
+        print(f"  ⚠ Error reading {pdf_path.name}: {e}")
+        return ""
+
+def extract_text_from_docx(docx_path):
+    """Extract text from DOCX file"""
+    try:
+        doc = docx.Document(docx_path)
+        text = '\n'.join([para.text for para in doc.paragraphs])
+        return text
+    except Exception as e:
+        print(f"  ⚠ Error reading {docx_path.name}: {e}")
+        return ""
+
+def extract_skills(text):
+    """Extract technical skills from resume text using comprehensive skill dictionary"""
+    # Comprehensive skill dictionary (from skill_dict.js)
+    SKILL_DICT = {
+        "Python": ["python", "python3", "cpython", "pypy"],
+        "Java": ["java", "openjdk", "jdk", "jvm"],
+        "JavaScript": ["javascript", "js", "nodejs", "ecmascript"],
+        "TypeScript": ["typescript", "ts"],
+        "C": [r"\bc\b", " c programming", "c language"],
+        "C++": ["c++", "cpp"],
+        "C#": ["c#", "csharp"],
+        "R": [r"\br\b", "r language", "r script"],
+        "SQL": [r"\bsql\b", "mysql", "postgresql", "postgres", "oracle", "sqlite", "mssql", "sql server"],
+        "NoSQL": ["nosql", "mongodb", "cassandra", "redis", "dynamodb", "couchdb"],
+        "Tableau": ["tableau", "tableau desktop", "tableau server"],
+        "Power BI": ["power bi", "powerbi"],
+        "MicroStrategy": ["microstrategy"],
+        "Excel": ["excel", "microsoft excel", "excel vba", "vba"],
+        "Spark": ["spark", "apache spark"],
+        "Hadoop": ["hadoop", "mapreduce", "hive"],
+        "Big Data": ["big data", "bigdata"],
+        "TensorFlow": ["tensorflow"],
+        "PyTorch": ["pytorch"],
+        "Keras": ["keras"],
+        "Scikit-Learn": ["scikit-learn", "sklearn", "scikit"],
+        "XGBoost": ["xgboost"],
+        "LightGBM": ["lightgbm"],
+        "Machine Learning": ["machine learning", "ml"],
+        "Deep Learning": ["deep learning", "neural network", "neural networks"],
+        "Data Science": ["data science", "data scientist", "data analytics", "analytics"],
+        "Data Engineering": ["data engineering", "etl", "data pipeline", "airflow", "dbt"],
+        "Airflow": ["airflow"],
+        "MLOps": ["mlops", "model deployment", "model serving", "sagemaker", "mlflow"],
+        "NLP": ["nlp", "natural language processing", "transformers", "spacy", "nltk"],
+        "Computer Vision": ["computer vision", "opencv", "cv"],
+        "Docker": ["docker", "containers"],
+        "Docker Compose": ["docker-compose", "compose"],
+        "Kubernetes": ["kubernetes", "k8s", "kube"],
+        "Helm": ["helm"],
+        "AWS": ["aws", "amazon web services", "ec2", "s3", "lambda", "cloudformation", "iam", "dynamodb"],
+        "Azure": ["azure", "microsoft azure", "azure functions", "azure devops"],
+        "GCP": ["gcp", "google cloud", "google cloud platform", "bigquery", "gce"],
+        "DevOps": ["devops", "ci/cd", "continuous integration", "continuous delivery", "continuous deployment"],
+        "CI/CD": ["jenkins", "circleci", "travis", "github actions", "gitlab ci", "azure pipelines"],
+        "Git": ["git", "github", "gitlab", "bitbucket"],
+        "REST API": ["rest", "restful api", "api", "web api"],
+        "GraphQL": ["graphql"],
+        "Django": ["django"],
+        "Flask": ["flask"],
+        "FastAPI": ["fastapi"],
+        "Node.js": ["node", "nodejs", "node.js"],
+        "Express": ["express"],
+        "Spring": ["spring", "spring boot"],
+        "Hibernate": ["hibernate"],
+        "SQLAlchemy": ["sqlalchemy"],
+        "React": ["react", "reactjs"],
+        "Angular": ["angular"],
+        "Vue.js": ["vue", "vue.js"],
+        "Svelte": ["svelte"],
+        "React Native": ["react native", "react-native"],
+        "Flutter": ["flutter", "dart"],
+        "Android": ["android", "android sdk"],
+        "iOS": ["ios", "ios sdk", "objective-c", "swift"],
+        "Mobile Development": ["mobile", "android", "ios"],
+        "UX Design": ["ux", "user experience", "user research", "wireframing", "prototyping", "figma", "adobe xd"],
+        "Figma": ["figma"],
+        "Sketch": ["sketch"],
+        "Photoshop": ["photoshop"],
+        "Illustrator": ["illustrator"],
+        "Business Intelligence": ["business intelligence", "bi", "tableau", "power bi", "microstrategy", "looker", "qlik"],
+        "Looker": ["looker"],
+        "Qlik": ["qlik", "qlikview", "qliksense"],
+        "DBT": ["dbt"],
+        "Fivetran": ["fivetran"],
+        "Stitch": ["stitch data", "stitch"],
+        "Kafka": ["kafka", "apache kafka"],
+        "RabbitMQ": ["rabbitmq"],
+        "Redis": ["redis"],
+        "Elasticsearch": ["elasticsearch", "elk", "elastic"],
+        "Neo4j": ["neo4j", "graph database"],
+        "MATLAB": ["matlab"],
+        "SAS": ["sas"],
+        "SPSS": ["spss"],
+        "Julia": ["julia"],
+        "Blockchain": ["blockchain", "ethereum", "smart contract", "solidity"],
+        "Solidity": ["solidity"],
+        "Unity": ["unity"],
+        "Unreal Engine": ["unreal engine"],
+        "Datadog": ["datadog"],
+        "New Relic": ["new relic"],
+        "Monitoring": ["prometheus", "grafana", "monitoring"],
+        "Logging": ["elk", "elasticsearch", "logstash", "kibana", "splunk"],
+        "Terraform": ["terraform"],
+        "Ansible": ["ansible"],
+        "Chef": ["chef"],
+        "Puppet": ["puppet"],
+        "Vagrant": ["vagrant"],
+        "VMware": ["vmware"],
+        "OpenShift": ["openshift"],
+        "Security": ["security", "oauth2", "jwt", "tls", "ssl", "vault", "gdpr", "hipaa"],
+        "Networking": ["networking", "dns", "tcp/ip", "http"],
+        "Project Management": ["project management", "project manager", "pmp", "scrum", "agile", "kanban"],
+        "Product Management": ["product management", "product manager", "roadmap", "user stories"],
+        "Business Analysis": ["business analysis", "business analyst", "requirements gathering"],
+        "Accessibility": ["a11y", "accessibility", "wcag"],
+        "Data Visualization": ["data visualization", "d3", "d3.js", "matplotlib", "seaborn", "ggplot2"],
+        "Matplotlib": ["matplotlib"],
+        "Seaborn": ["seaborn"],
+        "ggplot2": ["ggplot2"],
+        "Testing": ["testing", "selenium", "cypress", "unit test", "integration test", "pytest", "junit", "mocha", "jest"],
+        "Socket.io": ["socket.io"],
+        "Electron": ["electron"],
+        "Encryption": ["encryption", "openssl"],
+        "Pandas": ["pandas"],
+        "NumPy": ["numpy"],
+        "LookML": ["lookml"],
+        "Tableau Prep": ["tableau prep"],
+        "Power Query": ["power query"]
+    }
+    
+    found_skills = []
+    text_lower = text.lower()
+    
+    # Check each skill and its aliases
+    for skill_name, aliases in SKILL_DICT.items():
+        for alias in aliases:
+            # Use regex for word boundary patterns, simple search for others
+            if alias.startswith(r'\b'):
+                if re.search(alias, text_lower):
+                    found_skills.append(skill_name)
+                    break
+            else:
+                if alias in text_lower:
+                    found_skills.append(skill_name)
+                    break
+    
+    return found_skills
+
+def extract_education(text):
+    """Extract education level from resume"""
+    text_lower = text.lower()
+    if 'ph.d' in text_lower or 'phd' in text_lower or 'doctorate' in text_lower:
+        return 'PhD'
+    elif 'master' in text_lower or 'm.s.' in text_lower or 'msc' in text_lower or 'm.tech' in text_lower:
+        return 'Master'
+    elif 'bachelor' in text_lower or 'b.s.' in text_lower or 'b.tech' in text_lower or 'b.e.' in text_lower:
+        return 'Bachelor'
+    elif 'associate' in text_lower:
+        return 'Associate'
+    else:
+        return 'Bachelor'  # Default
+
+def extract_years_experience(text):
+    """Estimate years of experience from resume"""
+    # Look for years mentioned (e.g., "5 years", "3+ years")
+    years_pattern = r'(\d+)[\s]*[\+]*[\s]*(years?|yrs?)'
+    matches = re.findall(years_pattern, text.lower())
+    if matches:
+        years = [int(m[0]) for m in matches]
+        return max(years) if years else 0
+    
+    # Try to extract from date ranges (e.g., 2020-2023)
+    date_pattern = r'(20\d{2})\s*[-–—]\s*(20\d{2}|present|current)'
+    date_matches = re.findall(date_pattern, text.lower())
+    if date_matches:
+        total_years = 0
+        for start, end in date_matches:
+            end_year = 2025 if end in ['present', 'current'] else int(end)
+            total_years += end_year - int(start)
+        return min(total_years, 30)  # Cap at 30 years
+    
+    return np.random.randint(1, 8)  # Random fallback
+
+def extract_title(text):
+    """Extract job title from resume"""
+    titles = ['Data Engineer', 'Data Scientist', 'Software Engineer', 'Data Analyst', 
+              'Machine Learning Engineer', 'ML Engineer', 'Developer', 'Analyst',
+              'Engineer', 'Consultant', 'Manager', 'Architect', 'Scientist']
+    
+    text_lower = text.lower()
+    for title in titles:
+        if title.lower() in text_lower:
+            return title
+    return 'Software Engineer'  # Default
+
+def extract_location(text):
+    """Extract location from resume"""
+    us_cities = [
+        'San Francisco', 'Seattle', 'New York', 'Austin', 'Boston',
+        'Chicago', 'Los Angeles', 'Denver', 'Atlanta', 'Dallas',
+        'San Diego', 'Portland', 'Miami', 'Phoenix', 'Washington'
+    ]
+    
+    for city in us_cities:
+        if city.lower() in text.lower():
+            return city + ', USA'
+    
+    # Check for Indian cities
+    indian_cities = ['Mumbai', 'Bangalore', 'Delhi', 'Hyderabad', 'Pune', 'Chennai']
+    for city in indian_cities:
+        if city.lower() in text.lower():
+            return city + ', India'
+    
+    return 'Unknown'
+
+# Parse all resumes
+resume_dir = Path('dataset/Resume')
+data = []
+
+print("\n📄 Parsing resumes from:", resume_dir.absolute())
+print("=" * 80)
+
+for resume_file in resume_dir.iterdir():
+    if resume_file.suffix.lower() in ['.pdf', '.docx']:
+        print(f"  Processing: {resume_file.name}")
+        
+        # Extract text
+        if resume_file.suffix.lower() == '.pdf':
+            text = extract_text_from_pdf(resume_file)
+        else:
+            text = extract_text_from_docx(resume_file)
+        
+        if not text.strip():
+            print(f"  ⚠ Skipping (empty): {resume_file.name}")
+            continue
+        
+        # Extract features
+        candidate = {
+            'candidate_id': f'CAND-{len(data)+1:03d}',
+            'full_name': resume_file.stem.replace('_', ' ').replace('-', ' '),
+            'location': extract_location(text),
+            'education_level': extract_education(text),
+            'years_experience': extract_years_experience(text),
+            'skills': ', '.join(extract_skills(text)),
+            'current_title': extract_title(text),
+            'resume_file': resume_file.name,
+            'text_length': len(text)
+        }
+        data.append(candidate)
+        print(f"    ✓ Extracted: {candidate['current_title']}, {candidate['education_level']}, {len(extract_skills(text))} skills")
+
+df = pd.DataFrame(data)
+print(f"\n✓ Successfully parsed {len(df)} resumes")
+print(f"✓ Total unique skills found: {len(set([s for skills in df['skills'] for s in skills.split(', ') if s]))}")
+print("\n" + df[['candidate_id', 'full_name', 'current_title', 'education_level', 'years_experience']].to_string())
+print("\n" + "=" * 80)
+
+# ============================================================================
+# 2. FEATURE ENGINEERING
+# ============================================================================
+
+print("\n" + "=" * 80)
+print("FEATURE ENGINEERING")
+print("=" * 80)
+
+# One-Hot Encode categorical features
+ohe_features = ['education_level', 'current_title', 'location']
+ohe = OneHotEncoder(sparse_output=False, handle_unknown='ignore')
+ohe_encoded = ohe.fit_transform(df[ohe_features])
+ohe_feature_names = ohe.get_feature_names_out(ohe_features)
+
+print(f"✓ One-Hot Encoded features: {len(ohe_feature_names)} dimensions")
+
+# Vectorize skills (CountVectorizer for text)
+cv = CountVectorizer(max_features=50, min_df=2)
+skills_encoded = cv.fit_transform(df['skills']).toarray()
+
+print(f"✓ Skills vectorized: {skills_encoded.shape[1]} dimensions")
+
+# Combine all features
+X = np.hstack([
+    ohe_encoded,
+    skills_encoded,
+    df[['years_experience']].values
+])
+
+print(f"✓ Total features: {X.shape[1]} dimensions")
+
+# Scale features (important for K-Means)
+scaler = StandardScaler()
+X_scaled = scaler.fit_transform(X)
+
+print(f"✓ Features scaled with StandardScaler")
+
+# ============================================================================
+# 3. DETERMINE OPTIMAL K (Elbow Method + Silhouette)
+# ============================================================================
+
+print("\n" + "=" * 80)
+print("FINDING OPTIMAL NUMBER OF CLUSTERS")
+print("=" * 80)
+
+k_range = range(3, 10)
+silhouette_scores = []
+inertias = []
+
+for k in k_range:
+    kmeans = KMeans(n_clusters=k, random_state=42, n_init=10, max_iter=300)
+    labels = kmeans.fit_predict(X_scaled)
+    
+    silhouette = silhouette_score(X_scaled, labels)
+    inertia = kmeans.inertia_
+    
+    silhouette_scores.append(silhouette)
+    inertias.append(inertia)
+    
+    print(f"k={k} | Silhouette: {silhouette:.4f} | Inertia: {inertia:.2f}")
+
+# Select optimal k
+optimal_k = k_range[np.argmax(silhouette_scores)]
+optimal_silhouette = max(silhouette_scores)
+
+print(f"\n✓ OPTIMAL CLUSTERS: k={optimal_k} (Silhouette: {optimal_silhouette:.4f})")
+
+# ============================================================================
+# 4. TRAIN FINAL MODEL
+# ============================================================================
+
+print("\n" + "=" * 80)
+print(f"TRAINING FINAL K-MEANS MODEL (k={optimal_k})")
+print("=" * 80)
+
+kmeans_final = KMeans(n_clusters=optimal_k, random_state=42, n_init=20, max_iter=300)
+df['cluster'] = kmeans_final.fit_predict(X_scaled)
+
+print(f"✓ Model trained successfully")
+print(f"  • Number of clusters: {optimal_k}")
+print(f"  • Silhouette Score: {optimal_silhouette:.4f}")
+print(f"  • Inertia: {kmeans_final.inertia_:.2f}")
+
+# ============================================================================
+# 5. CLUSTER ANALYSIS
+# ============================================================================
+
+print("\n" + "=" * 80)
+print("CLUSTER STATISTICS")
+print("=" * 80)
+
+cluster_stats = df.groupby('cluster').agg({
+    'candidate_id': 'count',
+    'years_experience': ['mean', 'std'],
+}).round(2)
+
+cluster_stats.columns = ['count', 'avg_years_exp', 'std_years_exp']
+print(cluster_stats)
+
+# ============================================================================
+# 6. DETAILED CLUSTER PROFILES
+# ============================================================================
+
+print("\n" + "=" * 80)
+print("CLUSTER PROFILES")
+print("=" * 80)
+
+for cluster_id in range(optimal_k):
+    cluster_data = df[df['cluster'] == cluster_id]
+    cluster_size = len(cluster_data)
+    
+    print(f"\n{'=' * 80}")
+    print(f"CLUSTER {cluster_id} - {cluster_size} Candidates ({cluster_size/len(df)*100:.1f}%)")
+    print('=' * 80)
+    
+    print(f"\n📊 Statistics:")
+    print(f"  • Avg Experience: {cluster_data['years_experience'].mean():.1f} years")
+    print(f"  • Experience Range: {cluster_data['years_experience'].min()}-{cluster_data['years_experience'].max()} years")
+    
+    print(f"\n💼 Top Job Titles:")
+    top_titles = cluster_data['current_title'].value_counts().head(3)
+    for i, (title, count) in enumerate(top_titles.items(), 1):
+        pct = (count / cluster_size) * 100
+        print(f"  {i}. {title}: {count} ({pct:.1f}%)")
+    
+    print(f"\n🎓 Education Distribution:")
+    edu_dist = cluster_data['education_level'].value_counts()
+    for edu, count in edu_dist.items():
+        pct = (count / cluster_size) * 100
+        print(f"  • {edu}: {count} ({pct:.1f}%)")
+    
+    print(f"\n📍 Top Locations:")
+    top_locs = cluster_data['location'].value_counts().head(3)
+    for loc, count in top_locs.items():
+        pct = (count / cluster_size) * 100
+        print(f"  • {loc}: {count} ({pct:.1f}%)")
+
+# ============================================================================
+# 7. VISUALIZATION
+# ============================================================================
+
+print("\n" + "=" * 80)
+print("GENERATING VISUALIZATIONS")
+print("=" * 80)
+
+# Create output directory
+output_dir = Path('unsupervisedmloutput')
+output_dir.mkdir(exist_ok=True)
+print(f"✓ Output directory: {output_dir.absolute()}")
+
+# Plot 1: Elbow Method
+plt.figure(figsize=(12, 5))
+
+plt.subplot(1, 2, 1)
+plt.plot(k_range, inertias, 'bo-')
+plt.xlabel('Number of Clusters (k)')
+plt.ylabel('Inertia')
+plt.title('Elbow Method')
+plt.axvline(x=optimal_k, color='r', linestyle='--', label=f'Optimal k={optimal_k}')
+plt.legend()
+plt.grid(True)
+
+# Plot 2: Silhouette Scores
+plt.subplot(1, 2, 2)
+plt.plot(k_range, silhouette_scores, 'go-')
+plt.xlabel('Number of Clusters (k)')
+plt.ylabel('Silhouette Score')
+plt.title('Silhouette Analysis')
+plt.axvline(x=optimal_k, color='r', linestyle='--', label=f'Optimal k={optimal_k}')
+plt.legend()
+plt.grid(True)
+
+plt.tight_layout()
+plt.savefig(output_dir / 'cluster_evaluation.png', dpi=300, bbox_inches='tight')
+print("✓ Saved: unsupervisedmloutput/cluster_evaluation.png")
+
+# Plot 3: Cluster Distribution
+plt.figure(figsize=(10, 6))
+cluster_counts = df['cluster'].value_counts().sort_index()
+plt.bar(cluster_counts.index, cluster_counts.values, color='steelblue', edgecolor='black')
+plt.xlabel('Cluster ID')
+plt.ylabel('Number of Candidates')
+plt.title(f'Cluster Distribution (k={optimal_k})')
+for i, v in enumerate(cluster_counts.values):
+    plt.text(i, v + 1, str(v), ha='center', va='bottom')
+plt.savefig(output_dir / 'cluster_distribution.png', dpi=300, bbox_inches='tight')
+print("✓ Saved: unsupervisedmloutput/cluster_distribution.png")
+
+# Plot 4: Experience by Cluster
+plt.figure(figsize=(10, 6))
+df.boxplot(column='years_experience', by='cluster', figsize=(10, 6))
+plt.xlabel('Cluster ID')
+plt.ylabel('Years of Experience')
+plt.title('Experience Distribution by Cluster')
+plt.suptitle('')  # Remove default title
+plt.savefig(output_dir / 'experience_by_cluster.png', dpi=300, bbox_inches='tight')
+print("✓ Saved: unsupervisedmloutput/experience_by_cluster.png")
+
+# ============================================================================
+# 8. SAVE RESULTS
+# ============================================================================
+
+print("\n" + "=" * 80)
+print("SAVING RESULTS")
+print("=" * 80)
+
+# Save clustered data
+output_file = output_dir / 'candidate_clusters.csv'
+df.to_csv(output_file, index=False)
+print(f"✓ Saved clustered data to: {output_file}")
+
+# Save cluster summary
+summary_file = output_dir / 'cluster_summary.txt'
+with open(summary_file, 'w') as f:
+    f.write("CLUSTER SUMMARY\n")
+    f.write("=" * 80 + "\n\n")
+    f.write(f"Optimal number of clusters: {optimal_k}\n")
+    f.write(f"Silhouette Score: {optimal_silhouette:.4f}\n")
+    f.write(f"Total candidates: {len(df)}\n\n")
+    f.write(cluster_stats.to_string())
+
+print(f"✓ Saved summary to: {summary_file}")
+
+print("\n" + "=" * 80)
+print("CLUSTERING COMPLETE!")
+print("=" * 80)
+print(f"""
+✓ K-Means clustering model trained with {optimal_k} clusters
+✓ Silhouette Score: {optimal_silhouette:.4f}
+✓ All outputs saved to: unsupervisedmloutput/
+✓ Generated visualizations:
+  - unsupervisedmloutput/cluster_evaluation.png
+  - unsupervisedmloutput/cluster_distribution.png
+  - unsupervisedmloutput/experience_by_cluster.png
+✓ Results saved:
+  - unsupervisedmloutput/candidate_clusters.csv
+  - unsupervisedmloutput/cluster_summary.txt
+""")
diff --git a/unsupervisedmloutput/cluster_distribution.png b/unsupervisedmloutput/cluster_distribution.png
new file mode 100644
index 0000000..e769e80
Binary files /dev/null and b/unsupervisedmloutput/cluster_distribution.png differ
diff --git a/unsupervisedmloutput/cluster_evaluation.png b/unsupervisedmloutput/cluster_evaluation.png
new file mode 100644
index 0000000..74a0805
Binary files /dev/null and b/unsupervisedmloutput/cluster_evaluation.png differ
diff --git a/unsupervisedmloutput/cluster_summary.txt b/unsupervisedmloutput/cluster_summary.txt
new file mode 100644
index 0000000..4745ad2
--- /dev/null
+++ b/unsupervisedmloutput/cluster_summary.txt
@@ -0,0 +1,12 @@
+CLUSTER SUMMARY
+================================================================================
+
+Optimal number of clusters: 3
+Silhouette Score: 0.1779
+Total candidates: 19
+
+         count  avg_years_exp  std_years_exp
+cluster                                     
+0           15           6.67           4.72
+1            3           6.67           1.53
+2            1           5.00            NaN
\ No newline at end of file
diff --git a/unsupervisedmloutput/experience_by_cluster.png b/unsupervisedmloutput/experience_by_cluster.png
new file mode 100644
index 0000000..0a55bc3
Binary files /dev/null and b/unsupervisedmloutput/experience_by_cluster.png differ