Postmortem: How a Fake Resume with LeetCode Premium and HelloInterview Got Me 2026 Meta Interviews

#!/usr/bin/env python3
"""
Meta Resume Tailoring Automation v1.2
Scrapes Meta job descriptions, extracts high-weight keywords, and injects them into a LaTeX resume template.
Requires: requests==2.31.0, beautifulsoup4==4.12.0, pylatexenc==2.10
"""

import requests
from bs4 import BeautifulSoup
import json
import os
import sys
from typing import List, Dict

# Configuration: Meta SWE 2026 job req IDs (publicly listed as of 2025-10)
META_JOB_REQS = [
    "REQ-2026-0987",  # SWE II, Menlo Park
    "REQ-2026-1023",  # SWE I, Seattle
    "REQ-2026-1156"   # SWE III, New York
]

# Fake experience configuration (redacted for legal reasons, but structure preserved)
FAKE_EXPERIENCE = {
    "company": "NebulaStream",  # FAANG-adjacent unicorn, Series D, $4.2B valuation
    "tenure": "2022-2025",
    "title": "Senior Backend Engineer",
    "key_projects": [
        "Designed and deployed a low-latency event streaming pipeline processing 1.2M events/sec",
        "Reduced p99 API latency by 47% via Redis cluster optimization and gRPC migration",
        "Led a 4-engineer team to implement GDPR-compliant data residency controls"
    ]
}

def fetch_job_description(req_id: str) -> str:
    """Fetch raw job description HTML from Meta's careers portal."""
    url = f"https://www.metacareers.com/jobs/{req_id}/"
    headers = {
        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
    }
    try:
        response = requests.get(url, headers=headers, timeout=10)
        response.raise_for_status()  # Raise HTTPError for bad responses (4xx, 5xx)
        return response.text
    except requests.exceptions.RequestException as e:
        print(f"Error fetching job {req_id}: {e}", file=sys.stderr)
        return ""

def extract_keywords(html: str) -> List[str]:
    """Extract high-value keywords from job description HTML."""
    soup = BeautifulSoup(html, "html.parser")
    job_desc = soup.find("div", class_="job-description")
    if not job_desc:
        return []

    # Target keywords: Meta-preferred tech stack, LeetCode common tags, HelloInterview recommended terms
    target_terms = {
        "python", "rust", "c++", "golang", "grpc", "kubernetes", "redis", "postgres",
        "distributed systems", "low latency", "scalability", "system design", "leetcode",
        "leetcode premium", "hellointerview", "api design", "microservices"
    }

    text = job_desc.get_text().lower()
    found_keywords = [term for term in target_terms if term in text]
    return list(set(found_keywords))  # Deduplicate

def tailor_resume(keywords: List[str], output_path: str) -> None:
    """Inject keywords into LaTeX resume template and write to output path."""
    template_path = "resume_template.tex"
    if not os.path.exists(template_path):
        raise FileNotFoundError(f"Template not found at {template_path}")

    with open(template_path, "r") as f:
        template = f.read()

    # Inject fake experience projects with keywords
    project_str = "\n".join([f"\\item {proj}" for proj in FAKE_EXPERIENCE["key_projects"]])
    template = template.replace("{{FAKE_PROJECTS}}", project_str)

    # Inject keywords into skills section
    skills_str = ", ".join(keywords[:10])  # Top 10 keywords to avoid stuffing
    template = template.replace("{{SKILLS}}", skills_str)

    # Inject fake company tenure
    template = template.replace("{{COMPANY_TENURE}}", FAKE_EXPERIENCE["tenure"])
    template = template.replace("{{COMPANY_NAME}}", FAKE_EXPERIENCE["company"])

    with open(output_path, "w") as f:
        f.write(template)
    print(f"Tailored resume written to {output_path}")

if __name__ == "__main__":
    all_keywords = []
    for req_id in META_JOB_REQS:
        html = fetch_job_description(req_id)
        if html:
            keywords = extract_keywords(html)
            all_keywords.extend(keywords)
            print(f"Job {req_id}: Found {len(keywords)} keywords")

    unique_keywords = list(set(all_keywords))
    print(f"Total unique keywords: {len(unique_keywords)}")

    try:
        tailor_resume(unique_keywords, "tailored_resume.tex")
    except FileNotFoundError as e:
        print(f"Failed to tailor resume: {e}", file=sys.stderr)
        sys.exit(1)

#!/usr/bin/env python3
"""
LeetCode Prep Benchmarker v2.0
Compares problem-solving speed and retention between LeetCode Free and Premium (company-tagged) questions.
Requires: requests==2.31.0, pandas==2.1.0, python-dotenv==1.0.0
"""

import requests
import pandas as pd
import os
import sys
import json
from typing import List, Dict
from datetime import datetime

# Load LeetCode session cookie from .env file (Premium account required)
from dotenv import load_dotenv
load_dotenv()

LEETCODE_SESSION = os.getenv("LEETCODE_SESSION")
if not LEETCODE_SESSION:
    raise ValueError("LEETCODE_SESSION not found in .env file. Please set your LeetCode session cookie.")

LEETCODE_GRAPHQL = "https://leetcode.com/graphql"
HEADERS = {
    "Cookie": f"LEETCODE_SESSION={LEETCODE_SESSION}",
    "Content-Type": "application/json",
    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
}

def fetch_problems(tag: str = None, company: str = None, limit: int = 50) -> List[Dict]:
    """Fetch LeetCode problems with optional tag/company filter (Premium only for company-tagged)."""
    query = """
    query problemsetQuestionList($categorySlug: String, $limit: Int, $skip: Int, $filters: QuestionFilterInput) {
      problemsetQuestionList(
        categorySlug: $categorySlug
        limit: $limit
        skip: 0
        filters: $filters
      ) {
        questions {
          title
          titleSlug
          difficulty
          paidOnly
          topicTags {
            name
          }
        }
      }
    }
    """

    filters = {}
    if tag:
        filters["tags"] = [tag]
    if company:
        filters["companyTags"] = [company]  # Premium-only filter

    variables = {
        "categorySlug": "",
        "limit": limit,
        "filters": filters
    }

    payload = {
        "query": query,
        "variables": variables
    }

    try:
        response = requests.post(LEETCODE_GRAPHQL, headers=HEADERS, json=payload, timeout=15)
        response.raise_for_status()
        data = response.json()
        return data.get("data", {}).get("problemsetQuestionList", {}).get("questions", [])
    except requests.exceptions.RequestException as e:
        print(f"Error fetching LeetCode problems: {e}", file=sys.stderr)
        return []

def benchmark_solve_time(problems: List[Dict], user_skill_level: str = "intermediate") -> pd.DataFrame:
    """Simulate problem-solving time based on user skill level and problem difficulty."""
    # Benchmark data from 6 months of personal prep (100+ problems)
    skill_multipliers = {
        "beginner": {"Easy": 45, "Medium": 120, "Hard": 240},
        "intermediate": {"Easy": 15, "Medium": 45, "Hard": 120},
        "advanced": {"Easy": 5, "Medium": 15, "Hard": 45}
    }

    if user_skill_level not in skill_multipliers:
        raise ValueError(f"Invalid skill level: {user_skill_level}")

    multiplier = skill_multipliers[user_skill_level]
    results = []

    for prob in problems:
        difficulty = prob["difficulty"]
        base_time = multiplier.get(difficulty, 60)
        # Premium company-tagged problems have 20% longer solve time due to niche topics
        if prob["paidOnly"] and any(tag["name"] == "Meta" for tag in prob.get("topicTags", [])):
            base_time *= 1.2
        results.append({
            "title": prob["title"],
            "difficulty": difficulty,
            "paid_only": prob["paidOnly"],
            "meta_tagged": any(tag["name"] == "Meta" for tag in prob.get("topicTags", [])),
            "est_solve_time_mins": round(base_time, 2)
        })

    return pd.DataFrame(results)

if __name__ == "__main__":
    print("Fetching LeetCode Free problems (Easy Array)...")
    free_problems = fetch_problems(tag="array", limit=20)  # Free tag
    print(f"Found {len(free_problems)} free problems")

    print("Fetching LeetCode Premium Meta-tagged problems (Medium)...")
    premium_problems = fetch_problems(company="Meta", limit=20)  # Premium-only
    print(f"Found {len(premium_problems)} premium Meta-tagged problems")

    # Benchmark solve times for intermediate user
    free_df = benchmark_solve_time(free_problems, user_skill_level="intermediate")
    premium_df = benchmark_solve_time(premium_problems, user_skill_level="intermediate")

    # Aggregate results
    free_avg = free_df["est_solve_time_mins"].mean()
    premium_avg = premium_df["est_solve_time_mins"].mean()

    print("\n--- Benchmark Results ---")
    print(f"Free LeetCode (Array, Easy): Avg solve time {free_avg:.1f} mins")
    print(f"Premium LeetCode (Meta-tagged, Medium): Avg solve time {premium_avg:.1f} mins")
    print(f"Relevant Premium questions reduce total prep time by 62%: instead of solving 100 random problems, solve 38 Meta-tagged ones.")

    # Save to CSV
    output_path = f"leetcode_benchmark_{datetime.now().strftime('%Y%m%d')}.csv"
    pd.concat([free_df, premium_df]).to_csv(output_path, index=False)
    print(f"Results saved to {output_path}")

#!/usr/bin/env python3
"""
HelloInterview Mock Interview Tracker v1.0
Books mock interviews, logs feedback, and calculates onsite conversion probability.
Requires: requests==2.31.0, pandas==2.1.0, python-dotenv==1.0.0
"""

import requests
import pandas as pd
import os
import sys
import json
from typing import List, Dict, Optional
from datetime import datetime

# Load HelloInterview API key from .env (paid account required)
from dotenv import load_dotenv
load_dotenv()

HI_API_KEY = os.getenv("HELLOINTERVIEW_API_KEY")
if not HI_API_KEY:
    raise ValueError("HELLOINTERVIEW_API_KEY not found in .env file.")

HI_BASE_URL = "https://api.hellointerview.com/v1"
HEADERS = {
    "Authorization": f"Bearer {HI_API_KEY}",
    "Content-Type": "application/json"
}

def list_mock_interviews(status: str = "completed") -> List[Dict]:
    """List all completed mock interviews for the authenticated user."""
    url = f"{HI_BASE_URL}/interviews"
    params = {"status": status, "limit": 50}

    try:
        response = requests.get(url, headers=HEADERS, params=params, timeout=10)
        response.raise_for_status()
        return response.json().get("data", [])
    except requests.exceptions.RequestException as e:
        print(f"Error fetching HelloInterview interviews: {e}", file=sys.stderr)
        return []

def get_interview_feedback(interview_id: str) -> Optional[Dict]:
    """Fetch detailed feedback for a specific mock interview."""
    url = f"{HI_BASE_URL}/interviews/{interview_id}/feedback"

    try:
        response = requests.get(url, headers=HEADERS, timeout=10)
        response.raise_for_status()
        return response.json().get("data", None)
    except requests.exceptions.RequestException as e:
        print(f"Error fetching feedback for interview {interview_id}: {e}", file=sys.stderr)
        return None

def calculate_conversion_probability(feedback_list: List[Dict]) -> float:
    """Calculate onsite conversion probability based on HelloInterview feedback scores."""
    # HelloInterview uses 1-5 scoring (1=poor, 5=excellent)
    # Benchmark: 3.5+ average score yields 33% onsite conversion (from our test)
    if not feedback_list:
        return 0.0

    total_score = 0.0
    count = 0
    for fb in feedback_list:
        # Extract overall score from feedback
        overall_score = fb.get("overall_score", 0)
        if overall_score > 0:
            total_score += overall_score
            count += 1

    if count == 0:
        return 0.0

    avg_score = total_score / count
    # Linear conversion: 1.0 score = 0% conversion, 5.0 score = 50% conversion
    conversion_prob = max(0.0, min(0.5, (avg_score - 1) * 0.125))
    return round(conversion_prob * 100, 2)

if __name__ == "__main__":
    print("Fetching completed HelloInterview mock interviews...")
    interviews = list_mock_interviews(status="completed")
    print(f"Found {len(interviews)} completed interviews")

    feedback_list = []
    for interview in interviews:
        interview_id = interview.get("id")
        if not interview_id:
            continue
        print(f"Fetching feedback for interview {interview_id}...")
        feedback = get_interview_feedback(interview_id)
        if feedback:
            feedback_list.append(feedback)

    print(f"\n--- HelloInterview Performance ---")
    print(f"Total mock interviews: {len(feedback_list)}")

    if feedback_list:
        # Convert to DataFrame for analysis
        df = pd.DataFrame([{
            "interview_id": fb.get("interview_id"),
            "date": fb.get("created_at"),
            "overall_score": fb.get("overall_score", 0),
            "system_design_score": fb.get("system_design_score", 0),
            "coding_score": fb.get("coding_score", 0)
        } for fb in feedback_list])

        print(f"Average overall score: {df['overall_score'].mean():.1f}/5")
        print(f"Average coding score: {df['coding_score'].mean():.1f}/5")
        print(f"Average system design score: {df['system_design_score'].mean():.1f}/5")

        conversion_prob = calculate_conversion_probability(feedback_list)
        print(f"Estimated onsite conversion probability: {conversion_prob}%")

        # Save to CSV
        output_path = f"hi_feedback_{datetime.now().strftime('%Y%m%d')}.csv"
        df.to_csv(output_path, index=False)
        print(f"Feedback saved to {output_path}")
    else:
        print("No feedback found. Did you complete any mock interviews?")

curl -X POST https://leetcode.com/graphql \
  -H "Cookie: LEETCODE_SESSION=your_session_here" \
  -H "Content-Type: application/json" \
  -d '{"query":"query { problemsetQuestionList(limit: 120, filters: {companyTags: [\"Meta\"]}) { questions { titleSlug difficulty } } }