When trends interview navigating tech skills: A Comprehensive Guide

import requests
from bs4 import BeautifulSoup
import json
import time
from typing import List, Dict
import logging
from requests.exceptions import RequestException, HTTPError

# Configure logging to track scrape progress
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)

# Constants for target URLs and headers
LEVELS_FYI_URL = "https://www.levels.fyi/2024-tech-interview-trends"
BLIND_SURVEY_URL = "https://blind.com/api/survey/2024-interview-trends"
USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
REQUEST_TIMEOUT = 10  # Seconds to wait for response

def fetch_page(url: str) -> str:
    """Fetch HTML content from a URL with error handling and retries."""
    headers = {"User-Agent": USER_AGENT}
    max_retries = 3
    for attempt in range(max_retries):
        try:
            logger.info(f"Fetching {url} (attempt {attempt + 1}/{max_retries})")
            response = requests.get(url, headers=headers, timeout=REQUEST_TIMEOUT)
            response.raise_for_status()  # Raise HTTPError for 4xx/5xx responses
            return response.text
        except HTTPError as e:
            logger.error(f"HTTP error fetching {url}: {e}")
            if attempt == max_retries - 1:
                raise  # Re-raise after final retry
        except RequestException as e:
            logger.error(f"Request error fetching {url}: {e}")
            if attempt == max_retries - 1:
                raise
        time.sleep(2 ** attempt)  # Exponential backoff
    raise RequestException(f"Failed to fetch {url} after {max_retries} retries")

def parse_levels_fyi(html: str) -> List[Dict]:
    """Parse Levels.fyi trend page for interview topics and frequency."""
    soup = BeautifulSoup(html, "html.parser")
    trends = []
    # Find all trend rows in the table
    trend_rows = soup.select("table.trend-table tbody tr")
    for row in trend_rows:
        try:
            topic_elem = row.select_one("td.topic")
            freq_elem = row.select_one("td.frequency")
            if not topic_elem or not freq_elem:
                continue
            topic = topic_elem.text.strip()
            # Extract percentage from frequency text (e.g., "38% of FAANG interviews")
            freq_text = freq_elem.text.strip()
            freq = int(freq_text.split("%")[0]) if "%" in freq_text else 0
            trends.append({
                "source": "Levels.fyi",
                "topic": topic,
                "frequency_pct": freq,
                "raw_text": freq_text
            })
        except Exception as e:
            logger.warning(f"Failed to parse row: {e}")
            continue
    logger.info(f"Parsed {len(trends)} trends from Levels.fyi")
    return trends

def parse_blind_survey(html: str) -> List[Dict]:
    """Parse Blind survey page for trending topics."""
    soup = BeautifulSoup(html, "html.parser")
    trends = []
    # Blind survey uses card-based layout for topics
    topic_cards = soup.select("div.survey-card")
    for card in topic_cards:
        try:
            topic_elem = card.select_one("h3.card-title")
            mention_elem = card.select_one("span.mention-count")
            if not topic_elem or not mention_elem:
                continue
            topic = topic_elem.text.strip()
            mentions = int(mention_elem.text.strip().split(" ")[0])
            trends.append({
                "source": "Blind",
                "topic": topic,
                "mention_count": mentions,
                "raw_text": mention_elem.text.strip()
            })
        except Exception as e:
            logger.warning(f"Failed to parse card: {e}")
            continue
    logger.info(f"Parsed {len(trends)} trends from Blind")
    return trends

def save_trends(trends: List[Dict], output_path: str = "data/trending_topics.json") -> None:
    """Save scraped trends to JSON file with error handling."""
    try:
        with open(output_path, "w") as f:
            json.dump(trends, f, indent=2)
        logger.info(f"Saved {len(trends)} trends to {output_path}")
    except IOError as e:
        logger.error(f"Failed to save trends to {output_path}: {e}")
        raise

if __name__ == "__main__":
    all_trends = []
    # Scrape Levels.fyi
    try:
        levels_html = fetch_page(LEVELS_FYI_URL)
        levels_trends = parse_levels_fyi(levels_html)
        all_trends.extend(levels_trends)
    except Exception as e:
        logger.error(f"Failed to scrape Levels.fyi: {e}")
    # Scrape Blind
    try:
        blind_html = fetch_page(BLIND_SURVEY_URL)
        blind_trends = parse_blind_survey(blind_html)
        all_trends.extend(blind_trends)
    except Exception as e:
        logger.error(f"Failed to scrape Blind: {e}")
    # Save combined trends
    if all_trends:
        save_trends(all_trends)
    else:
        logger.error("No trends scraped, exiting")

import json
import pandas as pd
from typing import List, Dict, Optional
import logging
from pandas.errors import EmptyDataError, ParserError

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)

# Default skill map: maps existing skills to trending topics
DEFAULT_SKILL_MAP_PATH = "data/skill_map.json"
TREND_DATA_PATH = "data/trending_topics.json"
OUTPUT_PATH = "data/mapped_skills.json"

def load_json(path: str) -> Dict:
    """Load JSON file with error handling."""
    try:
        with open(path, "r") as f:
            data = json.load(f)
        logger.info(f"Loaded data from {path}")
        return data
    except FileNotFoundError:
        logger.error(f"File not found: {path}")
        raise
    except json.JSONDecodeError as e:
        logger.error(f"Invalid JSON in {path}: {e}")
        raise

def load_trend_data(path: str) -> pd.DataFrame:
    """Load trend data into DataFrame, handling errors."""
    try:
        df = pd.read_json(path)
        if df.empty:
            logger.warning(f"Trend data at {path} is empty")
        return df
    except (EmptyDataError, ParserError) as e:
        logger.error(f"Failed to load trend data: {e}")
        raise

def map_skills(existing_skills: List[str], skill_map: Dict, trend_df: pd.DataFrame) -> List[Dict]:
    """
    Map existing skills to trending topics using predefined skill map.

    Args:
        existing_skills: List of user's existing skills (e.g., ["Node.js", "PostgreSQL"])
        skill_map: Dict mapping existing skills to trending topics
        trend_df: DataFrame of trending topics with frequency

    Returns:
        List of mapped skills with trend alignment scores
    """
    mapped = []
    # Filter to top 10 trends by frequency
    top_trends = trend_df.sort_values(by="frequency_pct", ascending=False).head(10)
    for skill in existing_skills:
        # Get matching trending topics for this skill
        matching_topics = skill_map.get(skill, [])
        if not matching_topics:
            logger.debug(f"No matching topics for skill: {skill}")
            continue
        for topic in matching_topics:
            # Find trend data for this topic
            trend_row = top_trends[top_trends["topic"] == topic]
            if trend_row.empty:
                freq = 0
                source = "Unknown"
            else:
                freq = trend_row.iloc[0].get("frequency_pct", 0)
                source = trend_row.iloc[0].get("source", "Unknown")
            mapped.append({
                "existing_skill": skill,
                "trending_topic": topic,
                "trend_frequency_pct": freq,
                "source": source,
                "alignment_score": freq  # Higher frequency = better alignment
            })
    # Sort by alignment score descending
    mapped.sort(key=lambda x: x["alignment_score"], reverse=True)
    logger.info(f"Mapped {len(mapped)} skills to trending topics")
    return mapped

def calculate_gap_analysis(mapped_skills: List[Dict]) -> Dict:
    """Calculate skill gap analysis for interview prep."""
    if not mapped_skills:
        return {"total_gaps": 0, "top_gaps": []}
    # Group by trending topic to find gaps
    topic_groups = {}
    for item in mapped_skills:
        topic = item["trending_topic"]
        if topic not in topic_groups:
            topic_groups[topic] = []
        topic_groups[topic].append(item)
    # Find topics with no matching existing skills (gaps)
    all_trend_topics = set(item["trending_topic"] for item in mapped_skills)
    covered_topics = set(group[0]["trending_topic"] for group in topic_groups.values())
    gaps = all_trend_topics - covered_topics
    return {
        "total_mapped": len(mapped_skills),
        "total_gaps": len(gaps),
        "top_gaps": list(gaps)[:5],
        "top_aligned_topics": [item["trending_topic"] for item in mapped_skills[:3]]
    }

def save_mapped_skills(mapped: List[Dict], output_path: str) -> None:
    """Save mapped skills to JSON."""
    try:
        with open(output_path, "w") as f:
            json.dump(mapped, f, indent=2)
        logger.info(f"Saved mapped skills to {output_path}")
    except IOError as e:
        logger.error(f"Failed to save mapped skills: {e}")
        raise

if __name__ == "__main__":
    # Example existing skills (user would input their own)
    existing_skills = ["Node.js", "PostgreSQL", "React", "AWS Lambda", "REST APIs"]
    try:
        # Load data
        skill_map = load_json(DEFAULT_SKILL_MAP_PATH)
        trend_df = load_trend_data(TREND_DATA_PATH)
        # Map skills
        mapped = map_skills(existing_skills, skill_map, trend_df)
        # Calculate gap analysis
        gap_analysis = calculate_gap_analysis(mapped)
        logger.info(f"Gap analysis: {gap_analysis}")
        # Save results
        save_mapped_skills(mapped, OUTPUT_PATH)
        # Save gap analysis
        with open("data/gap_analysis.json", "w") as f:
            json.dump(gap_analysis, f, indent=2)
    except Exception as e:
        logger.error(f"Failed to map skills: {e}")

import json
from jinja2 import Environment, FileSystemLoader, TemplateError
from typing import List, Dict
import logging
import os
from datetime import datetime

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)

TEMPLATE_DIR = "templates"
TEMPLATE_NAME = "study_plan.md.j2"
MAPPED_SKILLS_PATH = "data/mapped_skills.json"
GAP_ANALYSIS_PATH = "data/gap_analysis.json"
OUTPUT_DIR = "output"

def load_json(path: str) -> Dict:
    """Load JSON file with error handling."""
    try:
        with open(path, "r") as f:
            return json.load(f)
    except FileNotFoundError:
        logger.error(f"File not found: {path}")
        raise
    except json.JSONDecodeError as e:
        logger.error(f"Invalid JSON in {path}: {e}")
        raise

def setup_jinja_env(template_dir: str) -> Environment:
    """Set up Jinja2 environment with error handling."""
    if not os.path.exists(template_dir):
        logger.error(f"Template directory not found: {template_dir}")
        raise FileNotFoundError(f"Template directory not found: {template_dir}")
    try:
        env = Environment(
            loader=FileSystemLoader(template_dir),
            autoescape=False,
            trim_blocks=True,
            lstrip_blocks=True
        )
        logger.info(f"Set up Jinja2 environment with template dir: {template_dir}")
        return env
    except Exception as e:
        logger.error(f"Failed to set up Jinja2 environment: {e}")
        raise

def generate_study_plan(mapped_skills: List[Dict], gap_analysis: Dict, env: Environment) -> str:
    """Generate markdown study plan from template."""
    try:
        template = env.get_template(TEMPLATE_NAME)
        # Prepare template context
        context = {
            "generated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "mapped_skills": mapped_skills,
            "gap_analysis": gap_analysis,
            "total_skills": len(mapped_skills),
            "top_topics": gap_analysis.get("top_aligned_topics", []),
            "gaps": gap_analysis.get("top_gaps", [])
        }
        # Render template
        study_plan = template.render(**context)
        logger.info("Rendered study plan template")
        return study_plan
    except TemplateError as e:
        logger.error(f"Template error: {e}")
        raise
    except Exception as e:
        logger.error(f"Failed to generate study plan: {e}")
        raise

def save_study_plan(study_plan: str, output_dir: str, filename: str = "study_plan.md") -> None:
    """Save generated study plan to file."""
    try:
        os.makedirs(output_dir, exist_ok=True)
        output_path = os.path.join(output_dir, filename)
        with open(output_path, "w") as f:
            f.write(study_plan)
        logger.info(f"Saved study plan to {output_path}")
    except IOError as e:
        logger.error(f"Failed to save study plan: {e}")
        raise

def add_benchmark_examples(study_plan: str, mapped_skills: List[Dict]) -> str:
    """Add benchmark code examples to study plan for each mapped skill."""
    benchmark_snippets = {
        "Node.js": "javascript
const http = require('http');
const server = http.createServer((req, res) => {
  res.writeHead(200);
  res.end('Hello World');
});
server.listen(3000, () => console.log('Server running on port 3000'));
",
        "PostgreSQL": "sql
CREATE TABLE users (id SERIAL PRIMARY KEY, name VARCHAR(100), created_at TIMESTAMP DEFAULT NOW());
INSERT INTO users (name) VALUES ('Alice');
SELECT * FROM users WHERE created_at > NOW() - INTERVAL '7 days';
",
        "AWS Lambda": "javascript
exports.handler = async (event) => {
  const response = {
    statusCode: 200,
    body: JSON.stringify('Hello from Lambda!'),
  };
  return response;
};
"
    }
    # Append benchmark examples for each mapped skill
    for skill in mapped_skills:
        existing_skill = skill["existing_skill"]
        if existing_skill in benchmark_snippets:
            study_plan += f"\n\n### Benchmark Example: {existing_skill}\n{benchmark_snippets[existing_skill]}"
    logger.info("Added benchmark examples to study plan")
    return study_plan

if __name__ == "__main__":
    try:
        # Load data
        mapped_skills = load_json(MAPPED_SKILLS_PATH)
        gap_analysis = load_json(GAP_ANALYSIS_PATH)
        # Set up Jinja2
        env = setup_jinja_env(TEMPLATE_DIR)
        # Generate study plan
        study_plan = generate_study_plan(mapped_skills, gap_analysis, env)
        # Add benchmark examples
        study_plan = add_benchmark_examples(study_plan, mapped_skills)
        # Save study plan
        save_study_plan(study_plan, OUTPUT_DIR)
        # Save as HTML too
        html_study_plan = f"{study_plan.replace('', '').replace('\n', '')}"
        save_study_plan(html_study_plan, OUTPUT_DIR, "study_plan.html")
    except Exception as e:
        logger.error(f"Failed to generate study plan: {e}")

// Map Node.js Express middleware to Go Gin middleware
func authMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        token := c.GetHeader("Authorization")
        if token != "valid-token" {
            c.AbortWithStatusJSON(401, gin.H{"error": "unauthorized"})
            return
        }
        c.Next()
    }
}
// Equivalent to Express: app.use((req, res, next) => { ... })

func BenchmarkGoHTTPServer(b *testing.B) {
    router := gin.Default()
    router.GET("/ping", func(c *gin.Context) {
        c.JSON(200, gin.H{"message": "pong"})
    })
    // Start server in goroutine
    go router.Run(":8080")
    // Warm up
    time.Sleep(1 * time.Second)
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        resp, err := http.Get("http://localhost:8080/ping")
        if err != nil {
            b.Fatal(err)
        }
        resp.Body.Close()
    }
}
// Run with: go test -bench=.

{
    "topic": "AWS Lambda Cold Starts",
    "questions": [
        "Explain the Lambda cold start lifecycle",
        "How would you reduce a 2s cold start to <200ms?",
        "What’s the tradeoff between provisioned concurrency and minifying dependencies?"
    ],
    "pass_criteria": [
        "Mentions init phase vs. invoke phase",
        "Cites specific tools: Lambda layers, provisioned concurrency, SnapStart",
        "Includes benchmark numbers for cold start reduction"
    ]
}

trend-interview-skill-mapper/
├── src/
│   ├── scraper.py          # Step 1: Trend scraper
│   ├── mapper.py           # Step 2: Skill mapper
│   ├── generator.py        # Step 3: Study plan generator
│   └── utils/
│       ├── config.py       # Config loader
│       └── benchmarks.py   # Benchmark helpers
├── tests/
│   ├── test_scraper.py
│   ├── test_mapper.py
│   └── test_generator.py
├── templates/
│   └── study_plan.md.j2    # Jinja2 template
├── data/
│   ├── trending_topics.json # Cached trend data
│   └── skill_map.json      # Default skill map
├── requirements.txt
└── README.md