salary negotiation mastering resume: When trends for Developers

import json
import re
import os
import sys
from typing import Dict, List, Tuple
from collections import Counter
import requests
from bs4 import BeautifulSoup

# Configuration constants
RESUME_PATH = "resume.json"
OUTPUT_PATH = "optimized_resume.json"
STOP_WORDS = {"the", "and", "for", "to", "in", "of", "a", "with", "on", "at", "by", "an", "is", "are", "was", "were"}

def load_resume(resume_path: str) -> Dict:
    """Load and validate a JSON resume against the jsonresume schema v3.2.1"""
    if not os.path.exists(resume_path):
        raise FileNotFoundError(f"Resume file not found at {resume_path}")
    try:
        with open(resume_path, "r") as f:
            resume = json.load(f)
        # Basic schema validation
        required_fields = ["basics", "work", "skills"]
        for field in required_fields:
            if field not in resume:
                raise ValueError(f"Missing required jsonresume field: {field}")
        return resume
    except json.JSONDecodeError as e:
        raise ValueError(f"Invalid JSON in resume file: {str(e)}")

def extract_jd_keywords(jd_url: str) -> List[str]:
    """Scrape job description from URL and extract high-value keywords"""
    try:
        response = requests.get(jd_url, timeout=10)
        response.raise_for_status()
    except requests.exceptions.RequestException as e:
        raise ConnectionError(f"Failed to fetch job description: {str(e)}")

    soup = BeautifulSoup(response.text, "html.parser")
    # Remove script/style tags to avoid noise
    for script in soup(["script", "style"]):
        script.decompose()
    jd_text = soup.get_text().lower()

    # Extract technical keywords (2+ character words, exclude stop words)
    words = re.findall(r"\b[a-z][a-z0-9+.#-]+\b", jd_text)
    filtered_words = [w for w in words if w not in STOP_WORDS and len(w) >= 2]
    # Count frequency and return top 50 keywords
    return [word for word, _ in Counter(filtered_words).most_common(50)]

def calculate_match_score(resume: Dict, jd_keywords: List[str]) -> Tuple[float, List[str]]:
    """Calculate ATS match score between resume and JD keywords"""
    # Extract all text from resume sections
    resume_text = []
    # Basics section
    if "basics" in resume:
        basics = resume["basics"]
        resume_text.append(basics.get("label", ""))
        resume_text.append(basics.get("summary", ""))
    # Work experience
    for job in resume.get("work", []):
        resume_text.append(job.get("position", ""))
        resume_text.append(job.get("summary", ""))
        for highlight in job.get("highlights", []):
            resume_text.append(highlight)
    # Skills
    for skill in resume.get("skills", []):
        resume_text.append(skill.get("name", ""))
        for keyword in skill.get("keywords", []):
            resume_text.append(keyword)

    full_resume_text = " ".join(resume_text).lower()
    matched_keywords = []
    for keyword in jd_keywords:
        if keyword in full_resume_text:
            matched_keywords.append(keyword)

    score = (len(matched_keywords) / len(jd_keywords)) * 100 if jd_keywords else 0
    return score, matched_keywords

def suggest_keywords(resume: Dict, jd_keywords: List[str], matched: List[str]) -> List[str]:
    """Suggest missing keywords to add to resume"""
    missing = [k for k in jd_keywords if k not in matched]
    # Filter to only technical keywords that can be added to skills section
    technical_missing = [k for k in missing if any(c.isdigit() or c in "+.#-" for c in k)]
    return technical_missing[:10]  # Return top 10 actionable suggestions

def main():
    try:
        # Load resume
        resume = load_resume(RESUME_PATH)
        print(f"Loaded resume for {resume['basics']['name']}")

        # Get JD URL from user
        jd_url = input("Enter job description URL: ").strip()
        if not jd_url.startswith(("http://", "https://")):
            raise ValueError("Invalid URL: must start with http:// or https://")

        # Extract keywords
        jd_keywords = extract_jd_keywords(jd_url)
        print(f"Extracted {len(jd_keywords)} keywords from JD")

        # Calculate match
        score, matched = calculate_match_score(resume, jd_keywords)
        print(f"ATS Match Score: {score:.1f}%")
        print(f"Matched Keywords: {', '.join(matched[:5])}...")

        # Get suggestions
        suggestions = suggest_keywords(resume, jd_keywords, matched)
        if suggestions:
            print("\nSuggested Keywords to Add:")
            for kw in suggestions:
                print(f"- {kw}")
        else:
            print("\nNo missing keywords found!")

    except Exception as e:
        print(f"Error: {str(e)}", file=sys.stderr)
        sys.exit(1)

if __name__ == "__main__":
    main()

import fs from "fs/promises";
import https from "https";
import { Resume } from "@jsonresume/schema";
import { IncomingMessage } from "http";

// Configuration
const GITHUB_USERNAME = process.env.GITHUB_USERNAME || "your-github-username";
const RESUME_OUTPUT = "resume.json";
const GITHUB_API = `https://api.github.com/users/${GITHUB_USERNAME}/repos?per_page=100&sort=stars`;

// Types for GitHub API response
interface GitHubRepo {
  name: string;
  stargazers_count: number;
  language: string;
  html_url: string;
  fork: boolean;
}

interface SkillBadge {
  name: string;
  level: "beginner" | "intermediate" | "advanced";
  url: string;
}

/**
 * Fetch top 10 non-forked GitHub repos by stars
 */
async function fetchGitHubRepos(): Promise {
  return new Promise((resolve, reject) => {
    const options = {
      headers: {
        "User-Agent": "Resume-Generator/1.0",
        ...(process.env.GITHUB_TOKEN ? { Authorization: `token ${process.env.GITHUB_TOKEN}` } : {}),
      },
    };

    https.get(GITHUB_API, options, (res: IncomingMessage) => {
      let data = "";
      res.on("data", (chunk) => (data += chunk));
      res.on("end", () => {
        try {
          const repos: GitHubRepo[] = JSON.parse(data);
          if (!Array.isArray(repos)) reject(new Error("Invalid GitHub API response"));
          // Filter out forks, sort by stars
          const filtered = repos
            .filter((repo) => !repo.fork)
            .sort((a, b) => b.stargazers_count - a.stargazers_count)
            .slice(0, 10);
          resolve(filtered);
        } catch (e) {
          reject(new Error(`Failed to parse GitHub response: ${e}`));
        }
      });
    }).on("error", (err) => reject(err));
  });
}

/**
 * Generate skill badges from top repos
 */
function generateSkillBadges(repos: GitHubRepo[]): SkillBadge[] {
  const langCount: Record = {};
  repos.forEach((repo) => {
    if (repo.language) langCount[repo.language] = (langCount[repo.language] || 0) + 1;
  });

  return Object.entries(langCount)
    .sort((a, b) => b[1] - a[1])
    .slice(0, 5)
    .map(([lang, count]) => ({
      name: lang,
      level: count > 3 ? "advanced" : count > 1 ? "intermediate" : "beginner",
      url: `https://github.com/search?q=user%3A${GITHUB_USERNAME}+language%3A${lang}`,
    }));
}

/**
 * Build full jsonresume schema compliant resume
 */
async function buildResume(): Promise {
  const repos = await fetchGitHubRepos();
  const badges = generateSkillBadges(repos);

  const resume: Resume = {
    basics: {
      name: "Jane Doe",
      label: "Senior Full Stack Engineer",
      email: "jane.doe@example.com",
      summary: "10+ years of experience building scalable distributed systems. Proven track record of leading teams and delivering high-impact features.",
      profiles: [
        { network: "GitHub", username: GITHUB_USERNAME, url: `https://github.com/${GITHUB_USERNAME}` },
        { network: "LinkedIn", username: "janedoe", url: "https://linkedin.com/in/janedoe" },
      ],
    },
    work: [
      {
        company: "TechCorp",
        position: "Senior Backend Engineer",
        startDate: "2021-01-01",
        endDate: "Present",
        summary: "Led migration of monolith to microservices, reducing deployment time by 60%.",
        highlights: [
          "Built 12+ REST APIs using Go and gRPC",
          "Implemented distributed tracing with Jaeger, reducing MTTR by 40%",
          "Mentored 4 junior engineers to promotion",
        ],
      },
    ],
    skills: [
      {
        name: "Programming Languages",
        keywords: badges.map((b) => b.name),
      },
      {
        name: "Verifiable Badges",
        keywords: badges.map((b) => `${b.name} (${b.level})`),
      },
    ],
    projects: repos.map((repo) => ({
      name: repo.name,
      description: `Top repo with ${repo.stargazers_count} stars`,
      url: repo.html_url,
      keywords: [repo.language].filter(Boolean) as string[],
    })),
  };

  return resume;
}

/**
 * Main execution
 */
async function main() {
  try {
    console.log("Generating jsonresume compliant resume...");
    const resume = await buildResume();
    await fs.writeFile(RESUME_OUTPUT, JSON.stringify(resume, null, 2));
    console.log(`Resume written to ${RESUME_OUTPUT}`);
    console.log(`View schema docs: https://github.com/jsonresume/resume-schema`);
  } catch (err) {
    console.error(`Failed to generate resume: ${err}`);
    process.exit(1);
  }
}

main();

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
    "sort"
    "strings"
    "time"
)

// Levels.fyi API response structures
type SalaryResponse struct {
    Data []SalaryEntry `json:"data"`
}

type SalaryEntry struct {
    Company    string  `json:"company"`
    Title      string  `json:"title"`
    Location   string  `json:"location"`
    BaseSalary float64 `json:"base_salary"`
    Stock      float64 `json:"stock"`
    Bonus      float64 `json:"bonus"`
    TotalComp  float64 `json:"total_comp"`
    YearsExp   int     `json:"years_exp"`
}

type BenchmarkResult struct {
    Percentile     int
    MedianMarket   float64
    YourOffer      float64
    Gap            float64
    RecommendedAsk float64
}

const (
    levelsAPI = "https://www.levels.fyi/api/v2/salaries?limit=1000&company=FAANG&title=Senior+Software+Engineer&location=San+Francisco"
    timeout   = 10 * time.Second
)

// fetchSalaries retrieves salary data from Levels.fyi API
func fetchSalaries() ([]SalaryEntry, error) {
    client := &http.Client{Timeout: timeout}
    req, err := http.NewRequest("GET", levelsAPI, nil)
    if err != nil {
        return nil, fmt.Errorf("failed to create request: %w", err)
    }
    // Set user agent to avoid 403
    req.Header.Set("User-Agent", "SalaryBenchmarker/1.0")

    resp, err := client.Do(req)
    if err != nil {
        return nil, fmt.Errorf("failed to fetch data: %w", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("API returned non-200 status: %d", resp.StatusCode)
    }

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("failed to read response: %w", err)
    }

    var salaryResp SalaryResponse
    if err := json.Unmarshal(body, &salaryResp); err != nil {
        return nil, fmt.Errorf("failed to parse JSON: %w", err)
    }

    return salaryResp.Data, nil
}

// calculateBenchmark compares your offer to market data
func calculateBenchmark(yourOffer float64, entries []SalaryEntry) (*BenchmarkResult, error) {
    if len(entries) == 0 {
        return nil, fmt.Errorf("no salary entries found")
    }

    // Filter to entries with total comp > 0
    validEntries := make([]float64, 0, len(entries))
    for _, entry := range entries {
        if entry.TotalComp > 0 {
            validEntries = append(validEntries, entry.TotalComp)
        }
    }

    if len(validEntries) == 0 {
        return nil, fmt.Errorf("no valid total compensation entries")
    }

    // Sort to calculate percentiles
    sort.Float64s(validEntries)
    median := validEntries[len(validEntries)/2]
    // Calculate 75th percentile as recommended ask
    percentile75 := validEntries[int(float64(len(validEntries))*0.75)]

    // Find your percentile
    yourPercentile := 0
    for _, val := range validEntries {
        if val <= yourOffer {
            yourPercentile++
        }
    }

    return &BenchmarkResult{
        Percentile:    int(float64(yourPercentile) / float64(len(validEntries)) * 100),
        MedianMarket:  median,
        YourOffer:     yourOffer,
        Gap:           median - yourOffer,
        RecommendedAsk: percentile75,
    }, nil
}

// printResults outputs benchmark results to console
func printResults(result *BenchmarkResult) {
    fmt.Println("=== Salary Benchmark Results ===")
    fmt.Printf("Your Offer: $%.2f\n", result.YourOffer)
    fmt.Printf("Market Median (FAANG Senior SWE SF): $%.2f\n", result.MedianMarket)
    fmt.Printf("Your Percentile: %dth\n", result.Percentile)
    fmt.Printf("Gap to Median: $%.2f\n", result.Gap)
    fmt.Printf("Recommended Ask (75th Percentile): $%.2f\n", result.RecommendedAsk)
    fmt.Println("=================================")
    if result.Gap > 0 {
        fmt.Printf("⚠️  Your offer is $%.2f below market median. Negotiate!\n", result.Gap)
    } else {
        fmt.Println("✅ Your offer is above market median. Well done!")
    }
}

func main() {
    fmt.Println("Fetching FAANG Senior SWE salary data from Levels.fyi...")
    entries, err := fetchSalaries()
    if err != nil {
        fmt.Printf("Error fetching salaries: %v\n", err)
        os.Exit(1)
    }
    fmt.Printf("Retrieved %d salary entries\n", len(entries))

    // Get user's offer
    var yourOffer float64
    fmt.Print("Enter your total compensation offer (base + stock + bonus): $")
    _, err = fmt.Scanf("%f", &yourOffer)
    if err != nil || yourOffer <= 0 {
        fmt.Println("Invalid offer amount")
        os.Exit(1)
    }

    result, err := calculateBenchmark(yourOffer, entries)
    if err != nil {
        fmt.Printf("Error calculating benchmark: %v\n", err)
        os.Exit(1)
    }

    printResults(result)
}

npx @jsonresume/cli init my-resume
npx @jsonresume/cli export my-resume.pdf --theme even --schema-version 3.2.1

curl -s "https://www.levels.fyi/api/v2/salaries?company=FAANG&title=Senior+Software+Engineer&location=San+Francisco" | jq '.data | sort_by(.total_comp) | reverse | .[0:5] | .[] | {company, title, total_comp}'

// Example badge entry in jsonresume skills section
{
  "name": "Verifiable Skills",
  "keywords": [
    "Go (Advanced) - 1.2k stars on GitHub",
    "gRPC (Intermediate) - 400 stars on GitHub",
    "LeetCode Rating: 2100 (Top 5%)"
  ]
}