Master the tips of salary negotiation and interview: What Fails

import requests
import json
from typing import Dict, List, Optional
import os
from dotenv import load_dotenv

# Load environment variables for API keys if needed
load_dotenv()

LEVELS_FYI_BASE_URL = "https://www.levels.fyi/api/v2/public/salary/search"
CACHE_FILE = "levels_fyi_cache.json"

class CompensationAnalyzer:
    """Fetches and analyzes real-time compensation data from Levels.fyi to inform salary negotiations."""

    def __init__(self, role: str, location: str, years_experience: int):
        self.role = role
        self.location = location
        self.years_experience = years_experience
        self.cached_data: Optional[Dict] = None
        self._load_cache()

    def _load_cache(self) -> None:
        """Load cached salary data from disk to avoid redundant API calls."""
        if os.path.exists(CACHE_FILE):
            try:
                with open(CACHE_FILE, 'r') as f:
                    self.cached_data = json.load(f)
            except json.JSONDecodeError:
                print("Warning: Cache file corrupted, fetching fresh data")
                self.cached_data = None
            except IOError as e:
                print(f"Warning: Could not read cache file: {e}")
                self.cached_data = None

    def _save_cache(self, data: Dict) -> None:
        """Persist fetched data to disk for future use."""
        try:
            with open(CACHE_FILE, 'w') as f:
                json.dump(data, f, indent=2)
        except IOError as e:
            print(f"Warning: Could not write to cache file: {e}")

    def fetch_market_data(self) -> List[Dict]:
        """Fetch salary data from Levels.fyi API with error handling."""
        # Check cache first
        cache_key = f"{self.role}_{self.location}_{self.years_experience}"
        if self.cached_data and cache_key in self.cached_data:
            print("Using cached market data")
            return self.cached_data[cache_key]

        # Prepare API request parameters
        params = {
            "role": self.role,
            "location": self.location,
            "yearsExperience": self.years_experience,
            "limit": 100  # Fetch up to 100 recent offers
        }

        try:
            response = requests.get(LEVELS_FYI_BASE_URL, params=params, timeout=10)
            response.raise_for_status()  # Raise HTTPError for bad responses (4xx, 5xx)
        except requests.exceptions.Timeout:
            raise RuntimeError("Request to Levels.fyi timed out. Check your network connection.")
        except requests.exceptions.HTTPError as e:
            raise RuntimeError(f"Levels.fyi API returned error: {e.response.status_code} {e.response.reason}")
        except requests.exceptions.RequestException as e:
            raise RuntimeError(f"Failed to fetch market data: {str(e)}")

        # Parse and filter response
        try:
            data = response.json()
            if not data.get("success"):
                raise RuntimeError(f"Levels.fyi API returned error: {data.get('message', 'Unknown error')}")

            salary_entries = data.get("data", [])
            # Filter to only include entries with valid base salary and total comp
            valid_entries = [
                entry for entry in salary_entries
                if entry.get("baseSalary") and entry.get("totalCompensation")
            ]

            # Update cache
            if not self.cached_data:
                self.cached_data = {}
            self.cached_data[cache_key] = valid_entries
            self._save_cache(self.cached_data)

            return valid_entries
        except json.JSONDecodeError:
            raise RuntimeError("Failed to parse Levels.fyi response as JSON")

    def calculate_market_range(self) -> Dict[str, float]:
        """Calculate 25th, 50th, 75th percentile total compensation from fetched data."""
        entries = self.fetch_market_data()
        if not entries:
            raise RuntimeError("No valid salary entries found for given criteria")

        total_comps = sorted([entry["totalCompensation"] for entry in entries])
        n = len(total_comps)

        return {
            "p25": total_comps[int(n * 0.25)],
            "p50": total_comps[int(n * 0.5)],
            "p75": total_comps[int(n * 0.75)],
            "sample_size": n
        }

if __name__ == "__main__":
    # Example usage: Analyze market data for Senior Backend Engineer in San Francisco
    try:
        analyzer = CompensationAnalyzer(
            role="Senior Software Engineer",
            location="San Francisco, CA",
            years_experience=8
        )
        market_range = analyzer.calculate_market_range()
        print(f"Market Compensation Range (Total Comp) for {analyzer.role} in {analyzer.location} with {analyzer.years_experience} years experience:")
        print(f"25th Percentile: ${market_range['p25']:,.2f}")
        print(f"50th Percentile (Median): ${market_range['p50']:,.2f}")
        print(f"75th Percentile: ${market_range['p75']:,.2f}")
        print(f"Sample Size: {market_range['sample_size']} recent offers")
    except RuntimeError as e:
        print(f"Error: {e}")
        exit(1)

const fs = require('fs');
const path = require('path');
const https = require('https');

/**
 * NegotiationEmailGenerator: Creates personalized, data-backed salary negotiation emails
 * using BATNA parameters and market compensation ranges.
 */
class NegotiationEmailGenerator {
    #marketData;
    #batnaValue;
    #candidateName;
    #hiringManagerName;
    #roleTitle;

    /**
     * @param {Object} config - Configuration object
     * @param {string} config.candidateName - Candidate's full name
     * @param {string} config.hiringManagerName - Hiring manager's full name
     * @param {string} config.roleTitle - Title of the role being negotiated
     * @param {Object} config.marketData - Market compensation range from analyzer
     * @param {number} config.batnaValue - Candidate's BATNA (best alternative offer value)
     */
    constructor(config) {
        this.#candidateName = config.candidateName;
        this.#hiringManagerName = config.hiringManagerName;
        this.#roleTitle = config.roleTitle;
        this.#marketData = config.marketData;
        this.#batnaValue = config.batnaValue;

        this.#validateConfig();
    }

    #validateConfig() {
        if (!this.#candidateName || typeof this.#candidateName !== 'string') {
            throw new Error('Invalid candidateName: must be a non-empty string');
        }
        if (!this.#hiringManagerName || typeof this.#hiringManagerName !== 'string') {
            throw new Error('Invalid hiringManagerName: must be a non-empty string');
        }
        if (!this.#roleTitle || typeof this.#roleTitle !== 'string') {
            throw new Error('Invalid roleTitle: must be a non-empty string');
        }
        if (!this.#marketData || !this.#marketData.p50 || !this.#marketData.p75) {
            throw new Error('Invalid marketData: must include p50 and p75 percentiles');
        }
        if (!this.#batnaValue || typeof this.#batnaValue !== 'number' || this.#batnaValue <= 0) {
            throw new Error('Invalid batnaValue: must be a positive number');
        }
    }

    /**
     * Generate a negotiation email for a counteroffer
     * @param {number} initialOffer - Initial offer total compensation
     * @returns {string} Formatted email template
     */
    generateCounterofferEmail(initialOffer) {
        if (typeof initialOffer !== 'number' || initialOffer <= 0) {
            throw new Error('initialOffer must be a positive number');
        }

        const targetComp = Math.max(
            this.#marketData.p75,
            this.#batnaValue * 1.1  // 10% premium over BATNA
        );

        const emailBody = `
Dear ${this.#hiringManagerName},

Thank you so much for extending the offer for the ${this.#roleTitle} position. I’m incredibly excited about the team’s work on [specific project from interview], and I’m eager to contribute to scaling your backend infrastructure.

After reviewing the offer details, I’ve done some research on market compensation for ${this.#roleTitle} roles in our location with my 8 years of experience. The median total compensation for this role is $${this.#marketData.p50.toLocaleString()}, with the 75th percentile at $${this.#marketData.p75.toLocaleString()}. I also have another offer in hand for $${this.#batnaValue.toLocaleString()} total comp, which I’d prefer to turn down given my interest in your team.

Based on my experience leading 3 major migrations that reduced p99 latency by 40% at my current role, I’d like to request a total compensation package of $${targetComp.toLocaleString()}. This aligns with the 75th percentile of market data and reflects the value I’ll bring to the team from day one.

I’m flexible on the structure of the package (base salary, equity, sign-on bonus) and open to discussing how we can get to this number. Let me know what time works for a quick call to chat through this.

Best regards,
${this.#candidateName}
        `.trim();

        return emailBody;
    }

    /**
     * Save generated email to disk
     * @param {string} emailContent - Email content to save
     * @param {string} [filename='negotiation_email.txt'] - Output filename
     */
    saveEmailToFile(emailContent, filename = 'negotiation_email.txt') {
        const outputPath = path.resolve(process.cwd(), filename);
        try {
            fs.writeFileSync(outputPath, emailContent, 'utf8');
            console.log(`Email saved to ${outputPath}`);
        } catch (err) {
            throw new Error(`Failed to save email to file: ${err.message}`);
        }
    }
}

// Example usage
try {
    const marketData = {
        p25: 280000,
        p50: 320000,
        p75: 380000,
        sample_size: 42
    };

    const generator = new NegotiationEmailGenerator({
        candidateName: 'Alex Chen',
        hiringManagerName: 'Jordan Lee',
        roleTitle: 'Senior Backend Engineer',
        marketData: marketData,
        batnaValue: 350000
    });

    const counterEmail = generator.generateCounterofferEmail(310000);
    generator.saveEmailToFile(counterEmail);
    console.log('Generated negotiation email:');
    console.log(counterEmail);
} catch (err) {
    console.error(`Error generating email: ${err.message}`);
    process.exit(1);
}

package main

import (
    "encoding/json"
    "fmt"
    "math/rand"
    "os"
    "strings"
    "time"
)

// SystemDesignQuestion represents a single system design interview question
type SystemDesignQuestion struct {
    ID          string   `json:"id"`
    Title       string   `json:"title"`
    Description string   `json:"description"`
    Constraints []string `json:"constraints"`
    Rubric      []string `json:"rubric"` // Evaluation criteria
}

// InterviewSimulator simulates system design interview sessions and evaluates candidate responses
type InterviewSimulator struct {
    questions     []SystemDesignQuestion
    currentQuestion *SystemDesignQuestion
    candidateResponse string
    score         int
}

// NewInterviewSimulator initializes a simulator with a question bank
func NewInterviewSimulator(questionBankPath string) (*InterviewSimulator, error) {
    // Seed random number generator
    rand.Seed(time.Now().UnixNano())

    // Load question bank from JSON file
    data, err := os.ReadFile(questionBankPath)
    if err != nil {
        return nil, fmt.Errorf("failed to read question bank: %w", err)
    }

    var questions []SystemDesignQuestion
    if err := json.Unmarshal(data, &questions); err != nil {
        return nil, fmt.Errorf("failed to parse question bank JSON: %w", err)
    }

    if len(questions) == 0 {
        return nil, fmt.Errorf("question bank is empty")
    }

    return &InterviewSimulator{
        questions: questions,
        score:     0,
    }, nil
}

// LoadRandomQuestion selects a random question from the bank
func (s *InterviewSimulator) LoadRandomQuestion() {
    idx := rand.Intn(len(s.questions))
    s.currentQuestion = &s.questions[idx]
    s.candidateResponse = ""
    s.score = 0
    fmt.Printf("Loaded question: %s\n", s.currentQuestion.Title)
}

// SubmitResponse records the candidate's response and performs initial validation
func (s *InterviewSimulator) SubmitResponse(response string) error {
    if strings.TrimSpace(response) == "" {
        return fmt.Errorf("response cannot be empty")
    }
    if len(response) < 200 {
        return fmt.Errorf("response is too short (min 200 characters required for valid submission)")
    }
    s.candidateResponse = response
    return nil
}

// EvaluateResponse scores the candidate's response against the rubric
func (s *InterviewSimulator) EvaluateResponse() (int, []string) {
    if s.currentQuestion == nil {
        return 0, []string{"No question loaded"}
    }
    if s.candidateResponse == "" {
        return 0, []string{"No response submitted"}
    }

    // Simple keyword-based evaluation (in real tool, use NLP or LLM integration)
    score := 0
    feedback := []string{}

    // Check for key system design terms
    requiredTerms := []string{"latency", "throughput", "scalability", "availability", "database", "cache"}
    for _, term := range requiredTerms {
        if strings.Contains(strings.ToLower(s.candidateResponse), term) {
            score += 15
            feedback = append(feedback, fmt.Sprintf("Mentioned key term: %s", term))
        }
    }

    // Check if response addresses constraints
    for _, constraint := range s.currentQuestion.Constraints {
        if strings.Contains(strings.ToLower(s.candidateResponse), strings.ToLower(constraint)) {
            score += 10
            feedback = append(feedback, fmt.Sprintf("Addressed constraint: %s", constraint))
        }
    }

    // Cap score at 100
    if score > 100 {
        score = 100
    }
    s.score = score

    return score, feedback
}

// SaveSessionResults saves the interview session to a JSON file
func (s *InterviewSimulator) SaveSessionResults(outputPath string) error {
    if s.currentQuestion == nil {
        return fmt.Errorf("no session to save")
    }

    session := map[string]interface{}{
        "question_id":   s.currentQuestion.ID,
        "question_title": s.currentQuestion.Title,
        "response":      s.candidateResponse,
        "score":         s.score,
        "timestamp":     time.Now().Format(time.RFC3339),
    }

    data, err := json.MarshalIndent(session, "", "  ")
    if err != nil {
        return fmt.Errorf("failed to marshal session data: %w", err)
    }

    if err := os.WriteFile(outputPath, data, 0644); err != nil {
        return fmt.Errorf("failed to write session file: %w", err)
    }

    fmt.Printf("Session results saved to %s\n", outputPath)
    return nil
}

func main() {
    // Example question bank (in practice, load from external JSON file)
    exampleQuestion := SystemDesignQuestion{
        ID:          "sysd-001",
        Title:       "Design a URL Shortener (e.g., bit.ly)",
        Description: "Design a scalable URL shortening service that can handle 100M URLs per day, with 1B redirects per day.",
        Constraints: []string{"Read-heavy (1000:1 read/write ratio)", "Low latency for redirects (<100ms p99)", "High availability (99.99%)"},
        Rubric:      []string{"Defines data model", "Explains caching strategy", "Addresses scalability", "Discusses monitoring"},
    }

    // Create simulator with example question
    simulator := &InterviewSimulator{
        questions: []SystemDesignQuestion{exampleQuestion},
    }

    // Run simulation
    simulator.LoadRandomQuestion()

    // Example candidate response (intentionally missing some terms to show evaluation)
    candidateResp := `To design a URL shortener, I would use a relational database to store the mapping between short codes and long URLs. For caching, I can use Redis to cache frequently accessed URLs. The service should be deployed on AWS with load balancers to handle traffic. I need to make sure it's scalable so we can add more servers if needed.`

    err := simulator.SubmitResponse(candidateResp)
    if err != nil {
        fmt.Printf("Error submitting response: %v\n", err)
        os.Exit(1)
    }

    score, feedback := simulator.EvaluateResponse()
    fmt.Printf("Evaluation Score: %d/100\n", score)
    fmt.Println("Feedback:")
    for _, f := range feedback {
        fmt.Printf("- %s\n", f)
    }

    // Save results
    if err := simulator.SaveSessionResults("interview_session.json"); err != nil {
        fmt.Printf("Error saving session: %v\n", err)
        os.Exit(1)
    }
}

# Quick snippet to get market p50 for your role
analyzer = CompensationAnalyzer("Senior Software Engineer", "Austin, TX", 7)
range = analyzer.calculate_market_range()
print(f"Market p50: ${range['p50']:,.2f}")

// Quick snippet to load a random system design question
sim, err := NewInterviewSimulator("question_bank.json")
if err != nil { log.Fatal(err) }
sim.LoadRandomQuestion()

// Quick snippet to generate a counteroffer email
const email = generator.generateCounterofferEmail(310000);
console.log(email);