S engines tokenize, weight, and evaluate candidate documents against role specifications.

Architecture Decisions

1. Modular Pipeline Stages: Parsing, keyword extraction, and scoring are separated to mirror real ATS architecture. This allows independent testing, format swapping, and scoring rule updates without breaking the core logic.
2. Positional Weighting: Keywords in headers, titles, and recent roles carry higher signal value. The scoring engine applies multipliers based on document structure.
3. Frequency & Recency Dampening: Over-repetition triggers spam filters. The engine caps keyword frequency impact and applies decay to older experience.
4. Deterministic Thresholding: A configurable cutoff score routes candidates to human review or automated rejection.

Implementation

interface CandidateProfile {
  fullName: string;
  contact: string;
  sections: {
    title: string;
    content: string;
    recencyScore: number; // 0.0 to 1.0 based on date proximity
  }[];
}

interface RoleSpecification {
  requiredSkills: string[];
  preferredSkills: string[];
  roleTitle: string;
}

interface ScoringConfig {
  exactMatchWeight: number;
  partialMatchWeight: number;
  headerMultiplier: number;
  bodyMultiplier: number;
  frequencyCap: number;
  recencyDecay: number;
  passThreshold: number;
}

class CandidateMatcher {
  private config: ScoringConfig;

  constructor(config: ScoringConfig) {
    this.config = config;
  }

  private tokenize(text: string): Set<string> {
    return new Set(
      text
        .toLowerCase()
        .replace(/[^a-z0-9\s]/g, '')
        .split(/\s+/)
        .filter(token => token.length > 2)
    );
  }

  private calculateOverlap(
    candidateTokens: Set<string>,
    targetTokens: string[]
  ): { matched: number; total: number; ratio: number } {
    let matched = 0;
    for (const skill of targetTokens) {
      const normalized = skill.toLowerCase().replace(/[^a-z0-9\s]/g, '');
      if (candidateTokens.has(normalized)) {
        matched++;
      }
    }
    return {
      matched,
      total: targetTokens.length,
      ratio: targetTokens.length > 0 ? matched / targetTokens.length : 0
    };
  }

  public evaluate(candidate: CandidateProfile, role: RoleSpecification): number {
    const allCandidateText = candidate.sections.map(s => s.content).join(' ');
    const candidateTokens = this.tokenize(allCandidateText);
    
    const requiredOverlap = this.calculateOverlap(candidateTokens, role.requiredSkills);
    const preferredOverlap = this.calculateOverlap(candidateTokens, role.preferredSkills);

    let rawScore = 0;
    rawScore += requiredOverlap.ratio * this.config.exactMatchWeight * 100;
    rawScore += preferredOverlap.ratio * this.config.partialMatchWeight * 100;

    // Apply positional and recency adjustments
    for (const section of candidate.sections) {
      const isHeader = section.title.toLowerCase().includes(role.roleTitle.toLowerCase());
      const multiplier = isHeader ? this.config.headerMultiplier : this.config.bodyMultiplier;
      const recencyFactor = Math.max(0.5, section.recencyScore * this.config.recencyDecay);
      
      rawScore *= (multiplier * recencyFactor);
    }

    // Frequency dampening simulation
    const cappedScore = Math.min(rawScore, this.config.frequencyCap * 100);
    
    return Math.round(cappedScore);
  }

  public meetsThreshold(score: number): boolean {
    return score >= this.config.passThreshold;
  }
}

Why This Architecture Works

• Tokenization Normalization: Stripping punctuation and lowercasing prevents false negatives from formatting variations (e.g., Kubernetes vs kubernetes).
• Separate Required/Preferred Pools: Mirrors how ATS platforms weight mandatory vs nice-to-have skills. Missing a required skill drops the score faster than missing a preferred one.
• Recency Decay: Older experience contributes less to the final score, reflecting how hiring teams prioritize recent, relevant work.
• Threshold Routing: The meetsThreshold method simulates the automated gate. Scores below the cutoff are archived; scores above proceed to human review.

This pipeline demonstrates that ATS evaluation is not mystical. It is a deterministic function of lexical overlap, structural placement, and temporal relevance. Optimizing your resume means feeding this function the correct inputs.

Pitfall Guide

1. Semantic Drift

Explanation: Using synonyms or abstract descriptions instead of exact terminology. ATS parsers rarely perform deep semantic inference. They match tokens. Fix: Replace container orchestration with Kubernetes. Replace deployment pipelines with CI/CD. Use the exact phrasing from the job description.

2. Layout Obfuscation

Explanation: Multi-column designs, tables, icons, and complex PDFs break text extraction engines. Parsers read linearly; non-linear layouts cause token scrambling or data loss. Fix: Use single-column, plain-text-friendly formats. Stick to standard headings, bullet points, and DOCX or simple PDF exports.

3. Keyword Dilution

Explanation: Stuffing keywords without context triggers spam filters and degrades readability for human reviewers. ATS systems often cap frequency impact. Fix: Integrate keywords naturally into achievement statements. Example: Implemented CI/CD using GitHub Actions to reduce deployment time by 40%.

4. Static Resume Syndrome

Explanation: Submitting the same document across multiple roles ignores the fact that ATS scoring is job-specific. Overlap metrics drop when terminology diverges. Fix: Maintain a master resume with all skills, then generate role-specific variants by swapping bullet points and adjusting section order to match the target description.

5. Recency Blindness

Explanation: Listing outdated technologies alongside current ones without temporal context confuses scoring engines that weight recent experience higher. Fix: Group older skills under a Legacy Technologies or Earlier Experience section. Prioritize current stack visibility in recent roles.

6. Format Incompatibility

Explanation: Submitting image-based PDFs, scanned documents, or heavily styled templates prevents text extraction entirely. Fix: Always export as text-selectable PDF or DOCX. Verify extractability by copying text into a plain editor before submission.

7. Missing Role Alignment

Explanation: Failing to mirror the job title or core responsibilities in your summary or recent role headings. Positional multipliers in ATS scoring heavily favor header matches. Fix: Align your most recent role title with the target role when accurate. Use the job description's exact phrasing in your professional summary.

Production Bundle

Action Checklist

• Extract exact terminology from the job description and map to your experience
• Replace abstract phrasing with explicit, tool-specific statements
• Convert resume to single-column, text-selectable format
• Verify keyword placement in headers, recent roles, and summary sections
• Generate a role-specific variant instead of using a static master document
• Run the document through a plain-text extractor to confirm parse integrity
• Apply recency weighting by prioritizing recent, relevant technologies
• Test against a scoring simulator before submission to validate threshold alignment

Decision Matrix

Scenario	Recommended Approach	Why	Cost Impact
Enterprise / High-Volume Role	Strict keyword alignment + standard formatting	ATS thresholds are rigid; parsers are legacy-heavy	Low (formatting adjustments only)
Startup / Direct Founder Review	Narrative clarity + technical depth	Human reviewers prioritize architecture and impact	Medium (requires custom tailoring)
Senior / Staff Engineer	Emphasize system design + leadership keywords	Scoring weights recency and role relevance heavily	Low (strategic bullet reordering)
Career Transition / Pivot	Hybrid approach: exact keywords + transferable skill mapping	Overlap will be lower; positional weighting compensates	Medium (requires experience translation)

Configuration Template

Use this TypeScript configuration to simulate ATS scoring behavior and validate your resume before submission. Adjust weights based on target company size and industry norms.

const atsScoringConfig: ScoringConfig = {
  exactMatchWeight: 0.7,      // Required skills carry 70% of base score
  partialMatchWeight: 0.3,    // Preferred skills carry 30%
  headerMultiplier: 1.4,      // Keywords in titles/headers get 40% boost
  bodyMultiplier: 1.0,        // Standard body text multiplier
  frequencyCap: 85,           // Max score before dampening triggers
  recencyDecay: 0.85,         // Older experience retains 85% weight
  passThreshold: 75           // Minimum score to route to human review
};

// Usage example
const matcher = new CandidateMatcher(atsScoringConfig);
const score = matcher.evaluate(candidateProfile, roleSpec);
console.log(`ATS Match Score: ${score}/100 | Pass: ${matcher.meetsThreshold(score)}`);

Quick Start Guide

1. Extract Keywords: Copy the job description into a text editor. Highlight required tools, frameworks, and methodologies. Remove fluff and keep exact terms.
2. Map & Rewrite: For each keyword, verify you have direct experience. Rewrite your bullet points to explicitly include the term in context. Avoid synonyms.
3. Format for Parsing: Convert your resume to a single-column DOCX or text-selectable PDF. Remove tables, columns, icons, and complex headers.
4. Validate Scoring: Run your document through a scoring simulator or manual overlap check. Ensure required skills appear in recent roles and section headers.
5. Submit & Iterate: Track response rates across variants. Adjust keyword placement and recency weighting based on pipeline feedback. Treat each application as a data point for continuous improvement.