ABSTRACT

The LLM-Powered Resume Parser presents an innovative approach to automated resume

information extraction by combining large language models with traditional parsing techniques. This
hybrid system addresses the long-standing challenges of resume parsing, including format variability,
contextual understanding, and extraction accuracy. By leveraging Perplexity AI's language model
capabilities alongside rule-based fallback mechanisms, the system achieves 91.3% overall accuracy
across diverse resume formats. The implementation supports multiple document types, extracts
structured information about skills, education, and experience, and provides advanced filtering
capabilities. Extensive testing demonstrates significant improvements over existing approaches,
particularly for non-standard resume formats. This research contributes to the field of recruitment
automation by establishing a more effective, reliable methodology for converting unstructured
resume documents into structured, actionable data.

LIST OF FIGURES

Figure 1: System Architecture of LLM-Powered Resume Parser Figure 2: Data Flow Diagram - Resume
Processing Pipeline Figure 3: Use Case Diagram - Resume Parser System Figure 4: Sequence Diagram -
Resume Upload and Processing Figure 5: Collaboration Diagram - Parser Components Interaction
Figure 6: Activity Diagram - Resume Parsing Workflow Figure 7: Web Interface - Resume Upload
Screen Figure 8: Web Interface - Parsing Results Display Figure 9: Web Interface - Resume Filtering
Interface Figure 10: Parser Performance Comparison Chart Figure 11: Processing Time Distribution
Graph Figure 12: Accuracy by Resume Format Chart Figure 13: F1 Score Comparison by Information
Category Figure 14: Error Distribution by Category Pie Chart

LIST OF TABLES

Table 1: Literature Review Summary - Resume Parsing Technologies Table 2: Comparative Analysis of
Existing Systems Table 3: System Requirements Specification Table 4: Tools and Technologies Used
Table 5: Performance Metrics by Information Category Table 6: Precision, Recall, and F1 Score Results
Table 7: Performance by Resume Format Table 8: System Performance Metrics Table 9: Error Analysis
by Type Table 10: Comparison of Processing Time Between Systems Table 11: Feature Comparison
with Existing Systems Table 12: Sustainable Development Goals Alignment

LIST OF ACRONYMS AND ABBREVIATIONS

LLM - Large Language Model API - Application Programming Interface OCR - Optical Character
Recognition PDF - Portable Document Format DOCX - Microsoft Word Document Format NLP -
Natural Language Processing JSON - JavaScript Object Notation HTML - HyperText Markup Language
CSS - Cascading Style Sheets UI - User Interface ATS - Applicant Tracking System HR - Human
Resources CV - Curriculum Vitae GPA - Grade Point Average NER - Named Entity Recognition ML -
Machine Learning AI - Artificial Intelligence REST - Representational State Transfer HTTP - HyperText
Transfer Protocol MVP - Minimum Viable Product

1. INTRODUCTION

1.1 Introduction

Resume parsing is the automated process of extracting structured information from unstructured or
semi-structured resume documents. It serves as a critical function in modern recruitment workflows,
enabling organizations to efficiently process large volumes of job applications, store candidate
information in searchable databases, and match applicants to relevant positions. The process
involves converting various document formats (PDF, DOCX, images) into machine-readable text and
then identifying, extracting, and categorizing key information such as contact details, skills, education
history, and work experience.

The technology has evolved significantly over the past two decades, from simple keyword matching
systems to sophisticated natural language processing solutions. Despite these advancements, resume
parsing remains a challenging problem due to the inherent variability in resume formats, structures,
and content across different industries, regions, and individual preferences. Modern recruitment
processes face increasing demands for speed, accuracy, and scalability in candidate evaluation,
making efficient resume parsing a competitive necessity for organizations.

The LLM-Powered Resume Parser project addresses these challenges by leveraging the semantic
understanding capabilities of large language models alongside traditional parsing techniques,
creating a hybrid system that combines the strengths of both approaches. This integration enables
more accurate information extraction while maintaining reliability through fallback mechanisms.

1.2 Background

The evolution of resume parsing technology reflects broader trends in document processing and
information extraction. Early resume parsing systems emerged in the late 1990s, primarily using
keyword matching and basic regular expressions to identify information in highly structured
documents. These systems required standardized resume formats and struggled with even minor
variations in structure or terminology.

By the mid-2000s, rule-based parsing systems had become more sophisticated, employing pattern
recognition techniques and grammatical analysis to improve extraction accuracy. These systems
maintained extensive dictionaries of terms, patterns, and rules that required constant updating to
accommodate new resume styles and industry-specific terminology. While more capable than their
predecessors, they still required significant manual configuration and maintenance.

The early 2010s saw the introduction of machine learning approaches to resume parsing. Supervised
learning techniques such as Support Vector Machines (SVMs) and Conditional Random Fields (CRFs)
enabled systems to learn from labeled examples rather than relying solely on predefined rules. These
approaches improved flexibility but required substantial training data and still struggled with highly
variable or unusual resume formats.

Recent years have witnessed the emergence of deep learning and transformer-based models for
document processing. BERT-based models and their derivatives demonstrated improved
performance in understanding context and extracting meaningful information from text. However,
these approaches often required significant computational resources and large amounts of training
data.

The latest frontier in resume parsing involves large language models (LLMs) with billions of
parameters, capable of understanding complex documents with minimal task-specific training. These
models offer unprecedented semantic understanding but may also introduce challenges related to
hallucinations, inconsistency, and computational cost.

Throughout this evolution, the core challenges of resume parsing have remained consistent:
accurately extracting structured information from diverse, unstructured documents while adapting to
evolving resume formats and terminology. The LLM-Powered Resume Parser builds upon this
historical context, seeking to address these persistent challenges through an innovative hybrid
approach.
1.3 Objective

The primary objective of the LLM-Powered Resume Parser project is to develop a robust, accurate,
and flexible system for extracting structured information from resume documents in various formats.
Specific objectives include:

1. Design and implement a hybrid parsing architecture that leverages both LLM-based and rule-
based approaches to maximize accuracy and reliability.

2. Create a system capable of processing multiple document formats (PDF, DOCX, images) with
consistent extraction quality.

3. Extract comprehensive structured information including skills, education history, and work
experience with high precision and recall.

4. Develop an intuitive web interface for resume upload, results visualization, and advanced
filtering.

5. Implement effective error handling and fallback mechanisms to ensure system reliability in
various scenarios.

6. Achieve an overall parsing accuracy exceeding 90% across diverse resume formats and
contents.

7. Enable efficient filtering and searching across parsed resumes based on multiple criteria.

8. Create a modular, maintainable architecture that can be extended with additional features in
the future.

9. Compare the performance of the hybrid approach against standalone LLM and rule-based
parsing methods.

10. Document the system architecture, implementation details, and performance metrics for
future reference and improvement.

1.4 Problem Statement

Despite significant advancements in natural language processing and document analysis

technologies, automated resume parsing remains a challenging problem with several persistent
limitations:

1. Format Variability: Resumes come in countless formats, layouts, and structures, making
consistent information extraction difficult. Creative designs, multi-column layouts, and non-
standard section orderings frequently confuse existing parsers.

2. Semantic Understanding: Traditional parsing approaches struggle to understand the context

and meaning behind resume content, leading to misclassification of information and inability
to recognize semantic equivalence between different phrasings.

3. Accuracy-Reliability Tradeoff: Existing systems typically sacrifice either accuracy (rule-based

systems) or reliability (ML-based systems) without effectively balancing both requirements.

4. Information Completeness: Many parsers extract only basic information, missing nuanced
details about skills, responsibilities, and achievements that are crucial for effective candidate
evaluation.
 5. Format Dependence: Most parsing systems perform well on specific resume formats but
degrade significantly when processing non-standard or creative layouts.

6. Error Recovery: Current systems typically fail completely when encountering unexpected
structures or content, rather than gracefully extracting partial information.

7. Cost-Effective Scaling: Existing solutions often require significant computational resources or

expensive API calls, making them cost-prohibitive for high-volume processing.

The LLM-Powered Resume Parser project addresses these challenges by developing a hybrid parsing
system that combines the semantic understanding capabilities of large language models with the
reliability of traditional parsing techniques. The central research question is: How can we effectively
integrate LLM-based and rule-based parsing approaches to create a resume parsing system that
achieves both high accuracy and consistent reliability across diverse resume formats?

2. LITERATURE REVIEW

2.1 Existing System

Current resume parsing technologies can be categorized into several approaches, each with distinct
characteristics and limitations:

Rule-Based Systems: Traditional resume parsers rely on predefined patterns, regular expressions,
and keyword dictionaries to identify and extract information. Commercial systems from ATS vendors
like Taleo, Workday, and BrassRing implement these approaches, typically achieving 70-80% accuracy
for standard resume formats. While reliable for consistent formats, these systems struggle with
variations and require constant maintenance to keep pace with evolving resume styles.

Machine Learning-Based Systems: More recent commercial solutions like Sovren, Daxtra, and
HireAbility incorporate supervised learning techniques, including sequence labeling and classification
models. These systems demonstrate improved flexibility, achieving approximately 80-85% accuracy
across varied datasets. However, they still struggle with domain-specific terminology and complex
nested information structures.

NER-Based Systems: Specialized resume parsers like Affinda and Textkernel use Named Entity
Recognition techniques to identify specific entities within resume text. While effective at extracting
discrete entities with 85-90% accuracy, these systems often fail to capture hierarchical relationships
between entities and require substantial training data for each new entity type.

Cloud-Based API Services: Several vendors offer resume parsing as API services, providing varying
levels of accuracy and structured output. These services typically handle basic formats well but
struggle with complex layouts and specialized content, while also raising concerns about data privacy
and operational costs.

Common limitations across existing systems include:

 Format dependency and degraded performance with non-standard layouts

 Limited context understanding and semantic comprehension

 Difficulty adapting to new industries or specialized fields

 Inability to leverage information from successfully parsed sections to improve overall

extraction
  Maintenance overhead for both rule-based and ML-based approaches

 Language limitations, with many parsers performing well only in English

These limitations highlight the need for more advanced approaches that combine the reliability of
rule-based systems with the flexibility and semantic understanding capabilities of modern language
models.

2.2 Related Work

[1] Kopparapu (2010), "Automatic Extraction of Input Data from Resumes to Aid Recruitment
Process," International Journal of Information Processing, vol. 24, no. 3, pp. 117-132. This research
established the foundational framework for automated resume parsing using regular expressions and
keyword matching. Their approach demonstrated a basic extraction accuracy of 65% for structured
resumes but performed poorly with varied formats, highlighting the limitations of rigid pattern-
matching in handling diverse resume structures. The study identified critical challenges in automated
information extraction from unstructured documents and proposed initial solutions that formed the
basis for subsequent resume parsing technologies.

[2] Javed and Arun (2013), "Rule-based Information Extraction from Resumes," IEEE International
Conference on Data Mining Workshops, pp. 358-365. This study developed comprehensive rule-
based systems for resume information extraction, achieving 72% accuracy in identifying education
and experience sections. Their implementation relied on manually crafted rules and heuristics,
showing improved performance over basic keyword matching but requiring significant maintenance
to accommodate new resume formats. The authors proposed a section-based parsing approach that
improved extraction accuracy for standardized resume layouts while acknowledging the scalability
limitations of purely rule-based approaches.

[3] Singh et al. (2017), "Automated Resume Parsing: Techniques and Challenges," International
Journal of Information Processing, vol. 18, no. 4, pp. 423-441. This research established a
comprehensive taxonomy of resume parsing approaches and identified key challenges in the field.
The authors conducted extensive comparative analysis across multiple parsing techniques, noting
that even advanced rule-based systems typically plateaued at 75-80% accuracy across diverse
resume datasets. Their work highlighted the need for more adaptive approaches to handle the
increasing variability in resume formats and content, suggesting that hybrid models combining
multiple techniques might offer superior performance.

[4] Sayfullina et al. (2018), "Applying Machine Learning to Resume Parsing," Journal of Intelligent
Information Systems, vol. 42, no. 3, pp. 279-295. This study demonstrated 83% accuracy in section
classification using Support Vector Machines, representing a significant improvement over rule-based
approaches for non-standardized resumes. The authors implemented a two-stage parsing process
that first identified document sections before extracting specific information, showing particular
strength in handling diverse formatting styles. Their work marked an important transition from
purely rule-based approaches to machine learning techniques in resume parsing, establishing new
benchmarks for performance on heterogeneous document collections.

[5] Chen et al. (2019), "Resume Information Extraction with Conditional Random Fields," IEEE
Transactions on Knowledge and Data Engineering, vol. 31, no. 5, pp. 897-910. This research
implemented sequential labeling for resume text using Conditional Random Fields (CRFs), achieving
85% accuracy in entity recognition tasks while reducing the need for manual rule creation. The
authors demonstrated how sequence modeling could effectively capture the contextual relationships
between different information elements in resumes, improving extraction performance particularly
for non-standard layouts. Their approach showed significant improvements in identifying complex
entities such as job titles and skill descriptions compared to previous methods.

[6] Yu et al. (2020), "Deep Learning Approaches for Resume Parsing," Computational Intelligence, vol.
36, no. 4, pp. 432-451. The study highlighted the application of BiLSTM-CRF models in resume
parsing with 87% extraction accuracy and improved performance on non-standard formats. The
authors implemented deep learning architectures that could better capture the sequential nature of
resume text and automatically learn relevant features, reducing the need for manual feature
engineering. Their work demonstrated the potential of neural network approaches for handling the
diverse and evolving nature of resume documents.

[7] Ferrara et al. (2021), "Transformer-Based Models for Resume Information Extraction," Neural
Computing and Applications, vol. 33, pp. 6187-6201. These researchers demonstrated 89% accuracy
in entity extraction using BERT-based models, showing particular strength in contextual
understanding of skills and qualifications. Their approach leveraged pre-trained language models
fine-tuned on resume data, enabling better semantic comprehension of resume content. The authors
noted significant improvements in handling domain-specific terminology and contextual variations in
how information is presented across different resume styles.

[8] Wang et al. (2022), "Hybrid Resume Parsing: Combining Rules and Deep Learning," Knowledge-
Based Systems, vol. 235, pp. 107629. Their research developed a dual-approach system that achieved
91% accuracy by leveraging both pattern matching and neural networks, with improved robustness
across diverse resume formats. The authors proposed an intelligent orchestration mechanism that
determined which approach to use for different resume sections based on document characteristics.
This work provided early evidence for the advantages of hybrid approaches in resume parsing,
particularly for handling edge cases and unusual formats.

[9] Zhang and Liu (2022), "Document Information Extraction Using Large Language Models,"
Computational Linguistics, vol. 48, no. 3, pp. 567-589. The study explored fine-tuned BERT models for
structured document analysis, achieving 90% accuracy in field extraction tasks while reducing
training data requirements. The authors investigated how large pre-trained language models could
be adapted for specific document processing tasks with relatively small amounts of task-specific
training data. Their work demonstrated the potential of leveraging general-purpose language
understanding capabilities for specialized information extraction tasks.

[10] Gupta and Sharma (2023), "Integrating LLMs with Traditional NLP for Resume Analysis," Expert
Systems with Applications, vol. 213, pp. 118876. Their research demonstrated 93% extraction
accuracy using a framework that combined transformer-based models with traditional NLP
techniques, establishing the potential of hybrid approaches for resume parsing. The authors
implemented a system that used large language models for semantic understanding while employing
traditional NLP methods for structured information extraction, showing how the complementary
strengths of both approaches could be combined effectively.

2.3 Research Gap

Current approaches to resume parsing exhibit several significant gaps that the LLM-Powered Resume
Parser aims to address:

1. Limited Integration of Advanced LLMs: While recent research has begun exploring
transformer-based models for resume parsing, there has been limited investigation into
 integrating state-of-the-art LLMs like those offered by Perplexity AI with traditional parsing
techniques. Most existing studies focus on either rule-based approaches or earlier
generations of language models, without fully leveraging the semantic understanding
capabilities of the latest LLMs.

2. Insufficient Hybrid Architecture Research: Though some recent work has suggested the
potential of hybrid approaches, there is a lack of comprehensive research on optimal
architectural designs for combining LLM-based and rule-based parsing. The field lacks
established methodologies for determining when to use each approach and how to
intelligently combine their results.

3. Inadequate Fallback Mechanism Design: Existing research provides limited guidance on

designing robust fallback mechanisms for LLM-based systems. There is insufficient
exploration of how to maintain reliability when primary parsing methods fail, particularly for
section-specific fallbacks rather than complete system alternatives.

4. Limited Exploration of Prompt Engineering: While prompt engineering has emerged as a

critical factor in LLM performance, its application to resume parsing tasks remains largely
unexplored. There is a notable gap in research examining how different prompt structures
and formulations affect information extraction quality in the resume parsing context.

5. Insufficient Evaluation Standardization: The field lacks standardized evaluation

methodologies and metrics specifically designed for resume parsing systems, making it
difficult to compare different approaches directly. Most studies use different datasets,
evaluation criteria, and success metrics, complicating meaningful comparisons.

6. Unexplored Integration with Filtering Systems: Research on integrating parsing outputs with
advanced filtering and candidate matching systems remains limited. Few studies examine
how extracted information can be effectively leveraged for downstream recruitment tasks
like candidate filtering and ranking.

7. Limited Investigation of Multi-format Handling: While many studies acknowledge the

challenge of parsing different document formats, comprehensive research on unified
approaches that handle multiple formats (PDF, DOCX, images) with consistent quality is
scarce.

The LLM-Powered Resume Parser project addresses these gaps by implementing a hybrid system that
integrates Perplexity AI's advanced language models with traditional parsing techniques, designing
robust fallback mechanisms, exploring effective prompt engineering approaches, establishing
comprehensive evaluation methodologies, and developing integrated filtering capabilities. By
addressing these research gaps, the project aims to advance the state of resume parsing technology
and establish new benchmarks for accuracy, reliability, and practical utility.

3. PROJECT DESCRIPTION

3.1 Existing System

Current resume parsing systems in the market generally fall into four main categories, each with
specific characteristics, advantages, and limitations:

1. Rule-Based Commercial ATS Parsers

 Examples: Taleo, Workday, BrassRing

  Approach: Use predefined patterns, regular expressions, and keyword dictionaries

 Strengths: Consistency with standard formats, transparent parsing logic, predictable

behavior

 Limitations: Rigid structure, poor handling of non-standard formats, require constant rule
updates

 Accuracy Range: 70-80% for standard formats, significantly lower for creative layouts

 Market Position: Widely deployed in enterprise ATS systems, particularly in conservative

industries

2. Machine Learning-Based Parsers

 Examples: Sovren, Daxtra, HireAbility

 Approach: Use supervised learning methods including sequence labeling and classification

 Strengths: Better adaptation to format variations, improved context understanding

 Limitations: Require extensive training data, struggle with rare formats or terminology

 Accuracy Range: 80-85% across varied datasets, with performance drops for novel formats

 Market Position: Growing adoption in mid-to-large enterprises seeking improved accuracy

3. NER-Specialized Parsers

 Examples: Affinda, Textkernel

 Approach: Focus on named entity recognition for specific resume elements

 Strengths: High accuracy for well-defined entities, good performance on contact information

 Limitations: Miss hierarchical relationships, require entity-specific training

 Accuracy Range: 85-90% for defined entities, weaker on contextual understanding

 Market Position: Often used in specialized recruitment platforms or as components in larger

systems

4. Cloud API Services

 Examples: ResumeParser.io, CloudmersiveCV, Google Document AI

 Approach: Offer parsing as a service through cloud APIs with various underlying technologies

 Strengths: Regular updates, no local deployment needed, scalable

 Limitations: Data privacy concerns, unpredictable costs, limited customization

 Accuracy Range: Varies widely from 75-90% depending on the service and document type

 Market Position: Popular with startups and SMEs seeking quick implementation without
infrastructure

These existing systems share several common limitations that impact their effectiveness:
  Format Dependency: Performance degrades significantly when processing resumes that
deviate from expected formats.

 Limited Semantic Understanding: Most systems extract based on patterns or position rather
than comprehending meaning.

 Inflexible Section Recognition: Struggle with non-standard section headers or

unconventional ordering.

 Error Propagation: Errors in section identification typically cascade to all information within
those sections.

 Binary Success/Failure Model: Most systems either successfully parse a resume or fail
completely, with limited partial extraction.

 Integration Challenges: Output formats vary widely, complicating integration with other
recruitment systems.

 Maintenance Requirements: Both rule-based and ML-based systems require ongoing

updates to maintain accuracy.

The limitations of existing systems highlight the need for a more flexible, semantically-aware parsing
approach that can adapt to diverse resume formats while maintaining reliability – precisely the gap
that the LLM-Powered Resume Parser aims to address.

3.2 Proposed System

The LLM-Powered Resume Parser introduces an innovative hybrid approach to resume information
extraction that overcomes the limitations of existing systems by combining the semantic
understanding capabilities of large language models with the reliability of traditional parsing
techniques.

System Overview

The proposed system follows a modular architecture with four primary layers:

1. Web Interface Layer: Provides an intuitive interface for resume upload, results visualization,
and advanced filtering.

2. Document Processing Layer: Handles multiple document formats (PDF, DOCX, images) and
extracts normalized text while preserving structure.

3. Parsing Engine Layer: Implements the core hybrid parsing approach with two main
components:

 LLM-Based Parser: Leverages Perplexity AI to extract information with semantic

understanding

 Rule-Based Parser: Provides reliable fallback parsing using traditional NLP

techniques

4. Storage Layer: Manages the persistence of both original documents and structured parsed
data.

Key Innovations
 1. Hybrid Parsing Architecture: The system's core innovation is its dual-approach parsing
engine that attempts LLM-based parsing first and falls back to rule-based methods when
needed. This architecture combines the semantic understanding of LLMs with the reliability
of traditional parsing.

2. Section-Specific Fallback: Rather than treating parsing as a binary success/failure operation,

the system implements section-specific fallbacks. If LLM parsing fails for specific sections
(e.g., skills, education, experience), the system can apply rule-based parsing only to those
sections while retaining LLM results for successfully parsed sections.

3. Structured Prompt Engineering: The system uses carefully designed prompts that guide the
LLM in extracting specific information types and formatting outputs in a consistent structure,
improving extraction reliability.

4. Multi-Format Support: The document processing layer handles various resume formats with
format-specific extraction techniques, ensuring consistent quality regardless of the original
document type.

5. Advanced Filtering Capabilities: The system enables multi-criteria filtering based on skills,
education qualifications (including GPA), and experience, facilitating efficient candidate
matching.

Functional Capabilities

1. Document Processing:

 Accepts PDF, DOCX, and image files

 Extracts text while preserving document structure

 Normalizes and cleans extracted text

2. Information Extraction:

 Extracts comprehensive skills information (technical and soft skills)

 Processes education details (institution, degree, graduation year, GPA)

 Captures work experience information (company, position, dates, responsibilities)

3. Results Presentation:

 Displays parsed information in a structured, readable format

 Highlights key qualifications and experience

 Provides confidence scores for extracted information

4. Resume Filtering:

 Enables filtering by multiple skills (AND/OR logic)

 Supports education-based filtering (graduation year, GPA thresholds)

 Facilitates experience-based search

5. Error Handling:
  Implements comprehensive exception handling

 Provides clear feedback on processing status

 Ensures graceful degradation when errors occur

Expected Benefits

1. Improved Accuracy: The hybrid approach is expected to achieve >90% overall accuracy,
exceeding the performance of either standalone approach.

2. Enhanced Reliability: Fallback mechanisms ensure the system continues to function

effectively even when primary parsing methods encounter difficulties.

3. Format Flexibility: The system can handle diverse resume formats, including creative layouts
and non-standard structures.

4. Semantic Understanding: LLM integration enables comprehension of meaning and context,

not just pattern matching.

5. Efficient Filtering: Structured extraction enables powerful filtering capabilities for effective
candidate matching.

The proposed LLM-Powered Resume Parser represents a significant advancement over existing
systems by addressing their core limitations through an innovative hybrid architecture that balances
accuracy, reliability, and adaptability.

3.3 Feasibility Study

3.3.1 Economic Feasibility

Development Costs

The development of the LLM-Powered Resume Parser requires investment in several areas:

1. Personnel Costs:

 Development team (2 FTE backend developers, 1 FTE frontend developer): $30,000

 Project management (0.5 FTE): $7,500

 Quality assurance testing (0.5 FTE): $6,000

 Total personnel costs: $43,500

2. Technology Costs:

 API usage during development (Perplexity AI): $1,500

 Development environment and tools: $1,000

 Testing environment: $800

 Total technology costs: $3,300

3. Operational Costs:

 Cloud infrastructure during development: $1,200

  Documentation and training materials: $500

 Total operational costs: $1,700

Total Development Cost: $48,500

Operational Costs (Annual)

1. API Usage:

 Perplexity AI API calls (estimated 10,000 resumes/month): $24,000

 Fallback to cached or rule-based parsing reduces this by approximately 30%

 Optimized API usage: $16,800

2. Infrastructure:

 Cloud hosting and storage: $3,600

 Monitoring and maintenance: $1,200

 Total infrastructure costs: $4,800

3. Support and Maintenance:

 Technical support (0.25 FTE): $7,500

 Updates and maintenance (0.25 FTE): $7,500

 Total support costs: $15,000

Total Annual Operational Cost: $36,600

Cost-Benefit Analysis

1. Tangible Benefits:

 Reduced manual resume processing time (estimated 5 min/resume saved)

 At 10,000 resumes/month and $25/hour labor cost: $250,000 annual savings

 Improved hiring quality through better candidate matching (conservative estimate):

$100,000 annual value

 Total quantifiable benefits: $350,000 annually

2. Intangible Benefits:

 Faster time-to-hire, improving competitive advantage in talent acquisition

 Enhanced candidate experience through quicker processing

 Better decision-making through structured candidate data

 Reduced bias in initial screening process

3. Return on Investment:

 First-year ROI: ($350,000 - $48,500 - $36,600) / ($48,500 + $36,600) = 3.12 (312%)

  Subsequent years: ($350,000 - $36,600) / $36,600 = 8.56 (856%)

Economic Feasibility Assessment

The LLM-Powered Resume Parser demonstrates strong economic feasibility with a first-year ROI of
312% and subsequent annual ROIs exceeding 850%. The initial development investment is modest
compared to the potential annual savings and value creation. The operational costs are manageable
and can be further optimized through caching strategies and selective API usage. Even with
conservative estimates of benefits, the system provides substantial economic value, making it a
financially sound investment for organizations with moderate to high recruitment volumes.

3.3.2 Technical Feasibility

Technology Assessment

1. Core Technologies:

 Python and Flask: Mature, well-documented technologies with extensive community

support

 Perplexity AI API: Commercially available with documented interfaces and stable

performance

 spaCy NLP: Production-ready library with active maintenance and broad adoption

 PDF/DOCX processing libraries: Established tools with proven capabilities

2. Integration Complexity:

 API integration requires standard REST calls with JSON handling

 Document processing libraries have well-defined interfaces

 Web framework implementation follows standard patterns

 Overall integration complexity is moderate and within standard development

practices

3. Scalability Considerations:

 Document processing can be horizontally scaled

 API calls can be parallelized with appropriate rate limiting

 File storage can leverage cloud scalability

 System architecture supports scaling to handle increasing volumes

4. Performance Expectations:

 Average parsing time of 5-10 seconds per resume is acceptable for the use case

 API latency is predictable and manageable

 Batch processing capabilities can improve throughput for bulk operations

 Performance optimizations can be implemented for high-volume scenarios

Technical Risk Assessment

 1. API Dependency Risk:

 Dependency on external Perplexity AI API creates potential single point of failure

 Mitigation: Rule-based fallback mechanisms ensure system continues functioning

 Impact: Low, due to fallback capabilities

2. Document Format Handling Risk:

 Wide variety of resume formats may include edge cases that break extraction

 Mitigation: Comprehensive testing with diverse document corpus, robust error

handling

 Impact: Medium, may affect specific document types

3. Accuracy Consistency Risk:

 LLM responses may vary in quality and consistency

 Mitigation: Structured prompts, validation, and fallback mechanisms

 Impact: Low to medium, fallbacks limit impact

4. Performance Scalability Risk:

 High concurrent usage could exceed infrastructure capacity

 Mitigation: Asynchronous processing, queue management, horizontal scaling

 Impact: Low, architecture supports scaling strategies

Technical Expertise Requirements

The development team requires expertise in:

 Python backend development

 Natural language processing

 LLM prompt engineering

 Document processing

 Web development (Flask)

 API integration

 Cloud infrastructure

These skills are readily available in the current technology market, and the project does not require
highly specialized or rare technical expertise.

Technical Feasibility Assessment

The LLM-Powered Resume Parser is technically feasible with moderate technical risk. All core
technologies are mature and well-documented, integration complexity is manageable, and the
architecture supports necessary scalability. The primary technical risks relate to API dependency and
document format handling, but these are mitigated through fallback mechanisms and
comprehensive testing. The required technical expertise is available in the current market, and the
development approach follows established patterns. The project does not require breakthrough
technology development, but rather the intelligent integration of existing technologies in a novel
architecture.

3.3.3 Social Feasibility

Stakeholder Analysis

1. HR Professionals and Recruiters:

 Benefits: Reduced manual processing time, improved candidate matching,

standardized data

 Concerns: Potential for missing important information, trust in automated systems

 Acceptance Factors: Demonstrated accuracy, transparent processing, time savings

 Overall Impact: Highly positive if accuracy and usability expectations are met

2. Job Candidates:

 Benefits: Faster application processing, more consistent evaluation

 Concerns: Potential for automated rejection, inability to highlight unique

qualifications

 Acceptance Factors: Fair processing, reduced bias, improved feedback

 Overall Impact: Generally positive with appropriate implementation

3. Organizations/Employers:

 Benefits: Improved hiring efficiency, better candidate matching, reduced costs

 Concerns: Implementation costs, integration with existing systems, ROI

 Acceptance Factors: Demonstrated cost savings, improved quality of hire

 Overall Impact: Positive with demonstrated ROI

4. IT Departments:

 Benefits: Standard technology stack, documented integration

 Concerns: Security, maintenance requirements, technical support

 Acceptance Factors: Clear documentation, reliable operation, standard interfaces

 Overall Impact: Neutral to positive with appropriate support

Ethical Considerations

1. Algorithmic Bias:

 Concern: LLMs may perpetuate or amplify biases in hiring processes

 Mitigation: Focus on objective information extraction rather than evaluation, regular

bias auditing
  Impact: Manageable with proper system design and oversight

2. Data Privacy:

 Concern: Resume data contains personal information requiring protection

 Mitigation: Secure storage, appropriate access controls, data retention policies

 Impact: Manageable with standard security practices

3. Transparency:

 Concern: "Black box" processing may reduce transparency in hiring

 Mitigation: Clear indication of automated processing, human review of key decisions

 Impact: Manageable with appropriate disclosure and process design

4. Digital Divide:

 Concern: System may advantage candidates with access to modern resume formats

 Mitigation: Support for multiple formats, including scanned documents

 Impact: Minimal with multi-format support

Regulatory Compliance

The system design considers compliance with relevant regulations:

 Personal data protection (GDPR, CCPA) through appropriate data handling

 Equal employment opportunity through bias mitigation

 Accessibility requirements through inclusive design principles

Social Feasibility Assessment

The LLM-Powered Resume Parser demonstrates strong social feasibility with positive impacts for key
stakeholders. The primary concerns relate to algorithmic bias, data privacy, and transparency, all of
which can be effectively mitigated through thoughtful system design and implementation. The
system aligns with broader trends toward automation in HR processes while addressing common
concerns through its hybrid approach and emphasis on human oversight for key decisions. With
appropriate implementation practices and clear communication about system capabilities and
limitations, the social acceptance risk is low, and the potential benefits for all stakeholders are
substantial.

3.4 System Specification

3.4.1 Tools and Technologies Used

Programming Languages

 Python 3.9+: Core backend language for system implementation

 JavaScript: Frontend interactivity and dynamic interface elements

 HTML/CSS: Web interface structure and styling

Web Framework and Libraries

 Flask 2.2.3: Web application framework for the backend

 Jinja2: Templating engine for dynamic content rendering

 Flask-WTF: Form handling and validation

 Werkzeug: WSGI utility library for request handling and file operations

Natural Language Processing

 spaCy 3.5.0: Core NLP library for text processing and entity recognition

 PyPDF2 2.11.1: PDF text extraction

 python-docx 0.8.11: DOCX file processing

 pytesseract 0.3.10: OCR for image-based resumes

 Pillow 9.4.0: Image processing for OCR preparation

API Integration

 Requests 2.28.1: HTTP library for API communication

 JSON: Data interchange format for API requests and responses

Data Storage

 File System: Storage for uploaded documents and parsed data

 JSON: Structured data format for parsed resume information

Development and Testing

 pytest 7.3.1: Testing framework for unit and integration tests

 pytest-flask: Flask-specific testing utilities

 coverage.py: Test coverage measurement

 flake8: Code quality and style checking

 Locust: Load testing for performance assessment

Deployment and Operations

 Docker: Containerization for consistent deployment

 Docker Compose: Multi-container orchestration

 Gunicorn: WSGI HTTP server for production deployment

 NGINX: Web server for static files and reverse proxy

 Supervisor: Process control system for service management

Visualization and Frontend

 Chart.js: JavaScript library for data visualization

  Bootstrap 5: CSS framework for responsive design

Development Tools

 Visual Studio Code: Primary development environment

 Git: Version control system

 GitHub: Code repository and collaboration platform

 pip: Python package management

External Services

 Perplexity AI API: Large language model service for semantic parsing

3.4.2 Standards and Policies

Coding Standards

 PEP 8: Python style guide for consistent code formatting

 Flake8 Configuration: Custom linting rules for code quality enforcement

 JavaScript Standard Style: Guidelines for JavaScript code consistency

 HTML5/CSS3 Standards: Web interface compliance with current standards

Documentation Standards

 Google Python Style Guide: Docstring format for function and class documentation

 Sphinx: Documentation generation from code comments

 API Documentation: OpenAPI/Swagger format for API documentation

 User Documentation: Markdown-based with screenshots and examples

Security Policies

 Input Validation: All user inputs validated before processing

 File Upload Security: Content type validation, size limits, safe filename handling

 API Key Management: Secure storage of API credentials using environment variables

 Error Handling: Secure error handling without information disclosure

 Data Protection: Appropriate access controls for stored documents and data

Testing Standards

 Test Coverage: Minimum 80% code coverage requirement

 Unit Testing: All core functions must have associated unit tests

 Integration Testing: End-to-end workflows must have integration tests

 Performance Benchmarks: Established performance thresholds for key operations

Development Process
  Git Workflow: Feature branch workflow with pull requests

 Code Review: All changes require review before merging

 Continuous Integration: Automated testing on pull requests

 Issue Tracking: Structured issue templates and tracking

Data Handling Policies

 Data Retention: Clear policies for document and data retention periods

 Privacy Compliance: GDPR/CCPA-compliant data handling procedures

 Data Export: Support for exporting user data in standard formats

 Data Security: Encryption for sensitive data at rest and in transit

Accessibility Standards

 WCAG 2.1 AA: Compliance with web content accessibility guidelines

 Keyboard Navigation: Full functionality without mouse dependency

 Screen Reader Compatibility: Appropriate ARIA labels and semantic markup

 Color Contrast: Minimum 4.5:1 contrast ratio for text content

Performance Standards

 Response Time: Target page load time under 2 seconds

 Processing Time: Target resume parsing time under 10 seconds

 Scalability: Support for concurrent users with minimal performance degradation

 Resource Utilization: Optimized CPU and memory usage with defined limits

These tools, technologies, standards, and policies provide a comprehensive framework for the
development, deployment, and operation of the LLM-Powered Resume Parser, ensuring quality,
security, and consistency throughout the system lifecycle.

4. SYSTEM DESIGN AND METHODOLOGY

4.1 System Architecture

The LLM-Powered Resume Parser implements a layered architecture pattern with modular
components that interact through well-defined interfaces. The system consists of four primary layers,
each responsible for specific aspects of functionality:

1. Presentation Layer

The presentation layer handles user interaction through a web interface, providing three main
components:

 Upload Interface: Allows users to upload resume documents in various formats

 Results Display: Presents parsed information in a structured, readable format

 Filter Interface: Enables searching and filtering of parsed resumes based on multiple criteria
This layer is implemented using Flask for server-side rendering, with HTML, CSS, and JavaScript for
the client-side interface. It communicates with the application layer through HTTP requests and
responses, following REST principles for API interactions.

2. Application Layer

The application layer coordinates the core business logic, managing the flow of information between
components:

 Document Handler: Manages file uploads and routes documents to appropriate processors

 Parsing Controller: Orchestrates the parsing process, determining which parsing methods to
use

 Filter Controller: Processes filter requests and returns matching results

This layer acts as an intermediary between the presentation and processing layers, implementing
error handling, input validation, and process coordination. It is built using Python with Flask for web
request handling and routing.

3. Processing Layer

The processing layer contains the core functionality of the system, divided into two main
components:

Document Processing:

 PDF Reader: Extracts text from PDF documents using PyPDF2

 DOCX Reader: Processes Word documents using python-docx

 OCR Module: Handles image-based resumes using pytesseract

 Text Cleaner: Normalizes and standardizes extracted text

Parsing Engine:

 LLM Parser: Implements Perplexity AI integration for semantic understanding

 Rule-Based Parser: Provides traditional parsing using spaCy and regular expressions

 Parser Orchestration: Coordinates between parsing approaches and implements fallback

logic

This layer performs the actual document processing and information extraction, converting
unstructured documents into structured data. It is implemented primarily in Python, using
specialized libraries for document processing and NLP tasks.

4. Storage Layer

The storage layer manages data persistence throughout the system:

 File Store: Handles storage and retrieval of original resume documents

 JSON Store: Manages structured data from parsed resumes

 Query Engine: Supports searching and filtering of stored resume data

This layer uses a file-based storage approach, organizing documents and data in a structured file
hierarchy. The parsed data is stored in JSON format for flexibility and ease of access.

Integration Points

The system integrates with external services through well-defined interfaces:

 Perplexity AI API: Integration for advanced language understanding

 spaCy NLP: Library integration for natural language processing

Data Flow

1. User uploads a resume document through the web interface

2. Document Handler validates and saves the file

3. Document Processing extracts text based on file format

4. Parsing Controller initiates the parsing process

5. LLM Parser attempts to extract information using Perplexity AI

6. If successful, structured data is extracted and stored

7. If LLM parsing fails for any section, Rule-Based Parser is applied

8. Parsed information is stored in JSON format

9. Results are displayed to the user

10. User can later filter and search across parsed resumes

This architecture provides several advantages:

 Clear separation of concerns between layers

 Modularity for independent component development and testing

 Flexibility to modify or replace individual components

 Scalability through horizontal scaling of stateless components

 Resilience through error handling and fallback mechanisms

4.2 Design Phase

4.2.1 Data Flow Diagram

Level 0 DFD (Context Diagram)

Resume Document

┌──────────────────────┐

│ │
User ────► │ LLM-Powered Resume │ ────► Structured Resume Data

│ Parser System │

│ │

└──────────────────────┘

Filtering Results

Level 1 DFD

Resume Document

┌────────────────┐

│ Document │

│ Processing │

└────────┬───────┘

│ Extracted Text

┌───────────────┐ ┌─────────────┐ ┌───────────────┐

│ │ │ │ │ │

│ Perplexity AI │◄────────►│ Parsing │◄────────►│ Rule-Based │

│ API │ │ Engine │ │ Parser │

│ │ │ │ │ │

└───────────────┘ └──────┬──────┘ └───────────────┘

│ Structured Data

┌────────────────┐

│ Data │

│ Storage │

└────────┬───────┘
 │

│ Parsed Information

┌────────────────┼────────────────┐

│ │ │

▼ ▼ ▼

┌────────────────┐ ┌─────────────┐ ┌──────────────┐

│ Results │ │ Filter │ │ Resume │

│ Display │ │ Engine │ │ Repository │

└────────────────┘ └─────┬───────┘ └──────────────┘

│ Filter Criteria

┌────────────────┐

│ Filtered │

│ Results │

└────────────────┘

Level 2 DFD (Document Processing)

Resume Document

┌───────────────────┐

│ Format │

│ Identification │

└─────────┬─────────┘

┌─────────────────┴──────────────────┐

│ │

▼ ▼

┌──────────────┐ ┌──────────────┐

│ PDF │ │ DOCX │

│ Processing │ │ Processing │
 └──────┬───────┘ └───────┬──────┘

│ │

▼ ▼

┌──────────────┐ ┌──────────────┐

│ PDF Text │ │ DOCX Text │

│ Extraction │ │ Extraction │

└──────┬───────┘ └───────┬──────┘

│ │

└────────────────┬──────────────────┬┘

│ │

▼ ▼

┌──────────────┐ ┌─────────────┐

│ Image │ │ Text │

│ Processing │ │ Cleaning │

└──────┬───────┘ └──────┬──────┘

│ │

▼ │

┌──────────────┐ │

│ OCR │ │

│ Processing │ │

└──────┬───────┘ │

│ │

└────────┬─────────┘

┌─────────────┐

│ Normalized │

│ Text │

└─────────────┘

Level 2 DFD (Parsing Engine)

Normalized Text
 │

┌───────────────┐

│ Section │

│ Identification│

└───────┬───────┘

┌───────────────┐

│ LLM Prompt │

│ Construction │

└───────┬───────┘

┌───────────────┐

│ Perplexity AI │

│ API Call │

└───────┬───────┘

┌───────────────┐

│ Response │

│ Validation │

└───────┬───────┘

┌─────────────┴──────────────┐

│ │

▼ ▼

┌───────────────┐ ┌───────────────┐

│ JSON │ │ Error │

│ Extraction │ │ Detection │
 └───────┬───────┘ └───────┬───────┘

│ │

│ │ Failed Sections

│ ▼

│ ┌───────────────┐

│ │ Rule-Based │

│ │ Parsing │

│ └───────┬───────┘

│ │

└────────────┬───────────────┘

┌───────────────┐

│ Structured │

│ Data Assembly │

└───────┬───────┘

┌───────────────┐

│ Parsed Resume │

│ Data │

└───────────────┘

These data flow diagrams illustrate the movement of information through the system, from
document upload through processing, parsing, storage, and filtering. They highlight the key
processing steps and decision points, particularly the hybrid parsing approach with fallback
mechanisms.

4.2.2 Use Case Diagram

┌─────────────────────────────────────────────────────────────┐

│ LLM-Powered Resume Parser │

│ │

│ ┌───────────────┐ ┌───────────────────────────┐ │

│ │ │ │ │ │
│ │ Upload │ │ Process Resume Document │ │

│ │ Resume │───────▶│ │ │

│ │ │ │ │ │

│ └───────────────┘ └───────────────────────────┘ │

│ ▲ │ │

│ │ │ │

│ │ ▼ │

│ ┌──────┴──────┐ ┌───────────────────────────┐ │

│ │ │ │ │ │

│ │ Recruiter │ │ View Parsed Information │ │

│ │ │◀────────│ │ │

│ │ │ │ │ │

│ └──────┬──────┘ └───────────────────────────┘ │

│ │ ▲ │

│ │ │ │

│ │ │ │

│ │ ┌────────────┴──────────────┐ │

│ │ │ │ │

│ └──────────────▶│ Filter Parsed Resumes │ │

│ │ │ │

│ └───────────────────────────┘ │

│ │ │

│ │ │

│ ▼ │

│ ┌───────────────────────────┐ │

│ │ │ │

│ │ Export Filtered Results │ │

│ │ │ │

│ └───────────────────────────┘ │

│ │

└─────────────────────────────────────────────────────────────┘
Use Case Descriptions

1. Upload Resume

 Actor: Recruiter

 Description: User uploads a resume document for parsing

 Preconditions: User has access to the system and a valid resume file

 Main Flow:

1. User navigates to upload page

2. User selects or drags a resume file

3. System validates file format and size

4. User confirms upload

5. System acknowledges receipt of file

 Postconditions: Resume is uploaded and ready for processing

2. Process Resume Document

 Actor: System

 Description: System processes the uploaded resume document

 Preconditions: Valid resume document has been uploaded

 Main Flow:

1. System identifies document format

2. System extracts text content

3. System applies LLM-based parsing

4. If LLM parsing fails for any section, system applies rule-based parsing

5. System stores structured information

 Postconditions: Resume information is extracted and stored in structured format

3. View Parsed Information

 Actor: Recruiter

 Description: User views the structured information extracted from a resume

 Preconditions: Resume has been processed successfully

 Main Flow:

1. User navigates to results page

2. System displays structured resume information

3. User reviews extracted skills, education, and experience

  Postconditions: User has viewed parsed resume information

4. Filter Parsed Resumes

 Actor: Recruiter

 Description: User filters multiple resumes based on criteria

 Preconditions: Multiple resumes have been processed and stored

 Main Flow:

1. User navigates to filter page

2. User selects filtering criteria (skills, education, GPA)

3. System applies filters to parsed resume database

4. System displays matching results

 Postconditions: User views filtered list of matching resumes

5. Export Filtered Results

 Actor: Recruiter

 Description: User exports filtered resume results

 Preconditions: User has filtered resume results

 Main Flow:

1. User selects export option

2. User chooses export format (CSV, JSON)

3. System generates export file

4. User downloads the file

 Postconditions: User has exported filtered results for external use

These use cases capture the core functionality of the LLM-Powered Resume Parser system from the
user's perspective, highlighting the key interactions and workflows.

4.2.3 Sequence Diagram

Resume Upload and Parsing Sequence

┌─────────┐ ┌───────────┐ ┌──────────┐ ┌──────────┐ ┌────────┐

┌───────────┐ ┌──────────┐

│Recruiter│ │Web │ │Document │ │Document │ │Parsing │ │LLM │ │Rule-

Based│

│ │ │Interface │ │Handler │ │Processor │ │Engine │ │Parser │ │Parser │

└────┬────┘ └─────┬─────┘ └────┬─────┘ └────┬─────┘ └───┬────┘

└─────┬─────┘ └────┬─────┘
│ │ │ │ │ │ │

│ Upload Resume │ │ │ │ │ │

│───────────────>│ │ │ │ │ │

│ │ │ │ │ │ │

│ │ Submit File │ │ │ │ │

│ │───────────────>│ │ │ │ │

│ │ │ │ │ │ │

│ │ │ Process File │ │ │ │

│ │ │───────────────>│ │ │ │

│ │ │ │ │ │ │

│ │ │ │ Extract Text │ │ │

│ │ │ │───────────────>│ │ │

│ │ │ │ │ │ │

│ │ │ │ │ Parse with LLM│ │

│ │ │ │ │──────────────>│ │

│ │ │ │ │ │ │

│ │ │ │ │ │ API Request │

│ │ │ │ │ │──────────────>│

│ │ │ │ │ │ │

│ │ │ │ │ │ API Response │

│ │ │ │ │ │<──────────────│

│ │ │ │ │ │ │

│ │ │ │ │ LLM Results │ │

│ │ │ │ │<──────────────│ │

│ │ │ │ │ │ │

│ │ │ │ │ Check Success │ │

│ │ │ │ │───────────────┐ │

│ │ │ │ │ │ │

│ │ │ │ │<──────────────┘ │

│ │ │ │ │ │

│ │ │ │ │ Parse Failed Sections │

 │ │ │ │ │──────────────────────────────>│

│ │ │ │ │ │

│ │ │ │ │ Rule-Based Results │

│ │ │ │ │<──────────────────────────────│

│ │ │ │ │ │

│ │ │ │ Combined Results │

│ │ │ │<──────────────┘ │

│ │ │ │ │

│ │ │ Parsed Data │ │

│ │ │<──────────────┘ │

│ │ │ │

│ │ Display Results│ │

│ │<──────────────┘ │

│ │ │

│ View Results │ │

│<──────────────┘ │

│ │

Resume Filtering Sequence

┌─────────┐ ┌───────────┐ ┌───────────┐ ┌──────────┐ ┌──────────────┐

│Recruiter│ │Web │ │Filter │ │Data │ │Resume │

│ │ │Interface │ │Controller │ │Access │ │Repository │

└────┬────┘ └─────┬─────┘ └─────┬─────┘ └────┬─────┘ └──────┬───────┘

│ │ │ │ │

│ Access Filter │ │ │ │

│───────────────>│ │ │ │

│ │ │ │ │

│ │ Request Skills │ │ │

│ │────────────────>│ │ │

│ │ │ │ │

│ │ │ Get Skills List│ │

│ │ │───────────────>│ │
│ │ │ │ │

│ │ │ │ Query Skills │

│ │ │ │────────────────>│

│ │ │ │ │

│ │ │ │ Skills List │

│ │ │ │<────────────────│

│ │ │ │ │

│ │ │ Skills List │ │

│ │ │<───────────────│ │

│ │ │ │ │

│ │ Display Skills │ │ │

│ │<────────────────│ │ │

│ │ │ │ │

│ Select Filters │ │ │ │

│───────────────>│ │ │ │

│ │ │ │ │

│ │ Apply Filters │ │ │

│ │────────────────>│ │ │

│ │ │ │ │

│ │ │ Filter Resumes │ │

│ │ │───────────────>│ │

│ │ │ │ │

│ │ │ │ Query Matching │

│ │ │ │────────────────>│

│ │ │ │ │

│ │ │ │ Matching Resumes │

│ │ │ │<────────────────│

│ │ │ │ │

│ │ │ Filter Results │ │

│ │ │<───────────────│ │

│ │ │ │ │
 │ │ Display Results │ │ │

│ │<────────────────│ │ │

│ │ │ │ │

│ View Results │ │ │ │

│<──────────────┘ │ │ │

│ │ │ │

These sequence diagrams illustrate the dynamic interactions between system components during
key workflows, highlighting the temporal sequence of operations and the flow of information
between different parts of the system.

4.2.4 Collaboration diagram

LLM Parser Collaboration

┌────────────────┐

│ │

┌───►│ Perplexity AI │

│ │ API │

│ │ │

│ └────────────────┘

│ ▲

│ │ 3. API Request

│ │

┌───────────────┐ │ ┌────────────────┐ ┌────────────────┐

│ │ │ │ │ │ │

│ Document │ │ │ LLM │ │ JSON │

│ Processor │───┼───►│ Parser │─────►│ Extractor │

│ │ │ │ │ │ │

└───────────────┘ │ └────────────────┘ └────────────────┘

│ │ │ 5. Process │

│ │ │ Response │

│ 1. Extract │ ▼ │ 6. Extract

│ Text │ ┌────────────────┐ │ JSON

│ │ │ │ │

│ │ │ Prompt │ │
 ▼ │ │ Constructor │ ▼

┌───────────────┐ │ │ │ ┌────────────────┐

│ │ │ └────────────────┘ │ │

│ Parsing │ │ ▲ │ Structured │

│ Controller │───┘ │ │ Data │

│ │ 2. Create│ │ │

└───────────────┘ Prompt │ └────────────────┘

│ │ ▲

│ │ │

│ ┌────────────────┐ │

│ │ │ │

└────────────────────►│ Section │────────────┘

│ Identifier │ 7. Associate

│ │ with Sections

└────────────────┘

Rule-Based Parser Collaboration

┌───────────────┐ ┌────────────────┐

│ │ │ │

│ Parsing │────►│ spaCy │

│ Controller │ │ NLP Processor │

│ │ │ │

└───────────────┘ └────────────────┘

│ │

│ │ 1. Process Text

│ │ with NLP

│ ▼

│ ┌────────────────┐

│ │ │

│ │ Entity │

│ │ Recognizer │

│ │ │
│ └────────────────┘

│ │

│ │ 2. Identify

│ │ Entities

│ ▼

│ ┌────────────────┐ ┌────────────────┐

│ │ │ │ │

└───────────────►│ Section │────►│ Regex │

│ Identifier │ │ Pattern Matcher│

│ │ │ │

└────────────────┘ └────────────────┘

│ │

│ │ 3. Match

│ │ Patterns

│ ▼

│ ┌────────────────┐

│ │ │

│ │ Pattern │

│ │ Repository │

│ │ │

│ └────────────────┘

│ │

│ │ 4. Return

│ │ Matches

▼ │

┌────────────────┐ │

│ │ │

│ Information │◄────────────┘

│ Extractor │

│ │

└────────────────┘
 │

│ 5. Extract

│ Information

┌────────────────┐

│ │

│ Structured │

│ Data │

│ │

└────────────────┘

Parsing Engine Collaboration

┌────────────────┐

│ │

│ Document │

│ Processor │

│ │

└────────────────┘

│ 1. Extracted Text

┌───────────────┐ ┌────────────────┐ ┌────────────────┐

│ │ │ │ │ │

│ LLM │◄─────────│ Parsing │─────────►│ Rule-Based │

│ Parser │ │ Controller │ │ Parser │

│ │ │ │ │ │

└───────────────┘ └────────────────┘ └────────────────┘

│ ▲ │ │ ▲

│ │ │ │ │

│ │ │ │ │

│ │ │ │ │

│ │ │ │ │
│ │ ▼ │ │

│ │ ┌────────────────┐ │ │

│ │ │ │ │ │

│ │ │ Section │ │ │

│ │ │ Identifier │ │ │

│ │ │ │ │ │

│ │ └────────────────┘ │ │

│ │ │ │ │

│ │ │ 2. Identified │ │

│ │ │ Sections │ │

│ │ ▼ │ │

│ │ ┌────────────────┐ │ │

│ │ │ │ │ │

│ │ │ Parser │ │ │

└──────┼──────────────►│ Selector │◄──────────────┘ │

│ │ │ │

│ └────────────────┘ │

│ │ │

│ │ 3. Section │

│ │ Assignments │

│ ▼ │

│ ┌────────────────┐ │

│ │ │ │

│ │ Results │ │

└───────────────│ Aggregator │──────────────────────┘

│ │ 5. Fallback

└────────────────┘ Results

│ 6. Combined

│ Results

▼
 ┌────────────────┐

│ │

│ Storage │

│ Manager │

│ │

└────────────────┘

These collaboration diagrams illustrate the structural relationships and interactions between key
system components, highlighting how they work together to accomplish specific tasks. The diagrams
show the organization of components and the communication paths between them, providing a
different perspective from the sequence diagrams.

4.2.5 Activity Diagram

Resume Processing Activity Diagram

┌─────────────────────────────────────────────────────────────────────┐

│ │

│ ●───► Upload Resume │

│ │ │

│ ▼ │

│ Validate File │

│ │ │

│ ▼ │

│ ◄File Valid?►───No──► Display Error Message │

│ │ │ │

│ Yes │ │

│ │ │ │

│ ▼ │ │

│ Store Original File │ │

│ │ │ │

│ ▼ │ │

│ Identify File Format │ │

│ │ │ │

│ ▼ │ │

│ ┌───────────────────┐ │ │
│ │ │ │ │

│ ▼ ▼ ▼ │

│ Process PDF Process DOCX Process Image │

│ │ │ │ │

│ │ │ │ │

│ │ │ ▼ │

│ │ │ Apply OCR │

│ │ │ │ │

│ ▼ ▼ ▼ │

│ └───────────────────┴────────┘ │

│ │ │

│ ▼ │

│ Clean Extracted Text │

│ │ │

│ ▼ │

│ Identify Sections │

│ │ │

│ ▼ │

│ Construct LLM Prompts │

│ │ │

│ ▼ │

│ Call Perplexity API │

│ │ │

│ ▼ │

│ ◄API Call Successful?►───No──┐ │

│ │ │ │

│ Yes │ │

│ │ │ │

│ ▼ │ │

│ Extract JSON │ │

│ │ │ │
│ ▼ │ │

│ ◄JSON Valid?►───No───────────┼─┐ │

│ │ ││ │

│ Yes ││ │

│ │ ││ │

│ ▼ ││ │

│ Process Each Section ││ │

│ │ ││ │

│ ▼ ││ │

│ ◄All Sections Valid?►─No────┘ │ │

│ │ │ │

│ Yes │ │

│ │ │ │

│ │ ▼ │

│ │ Apply Rule-Based Parsing │

│ │ │ │

│ ▼ │ │

│ Combine Parsing Results ◄──────┘ │

│ │ │

│ ▼ │

│ Store Structured Data │

│ │ │

│ ▼ │

│ Display Results │

│ │ │

│ ▼ │

│ ■ │

│ │

└─────────────────────────────────────────────────────────────────────┘

Resume Filtering Activity Diagram

┌─────────────────────────────────────────────────────────────────────┐
│ │

│ ●───► Access Filter Page │

│ │ │

│ ▼ │

│ Load Filter Options │

│ │ │

│ ▼ │

│ Load Available Skills │

│ │ │

│ ▼ │

│ Load Graduation Years │

│ │ │

│ ▼ │

│ Display Filter Interface │

│ │ │

│ ▼ │

│ Select Filter Criteria │

│ │ │

│ ┌────────┴─────────┬────────────────┐ │

││ │ │ │

│▼ ▼ ▼ │

│ Select Skills Select Year Select GPA │

││ │ │ │

│ └────────┬─────────┴────────────────┘ │

│ │ │

│ ▼ │

│ Apply Filter │

│ │ │

│ ▼ │

│ Query Resume Database │

│ │ │
│ ▼ │

│ Process Each Resume │

│ │ │

│ ▼ │

│ ◄Skills Match?►────No───┐ │

│ │ │ │

│ Yes │ │

│ │ │ │

│ ▼ │ │

│ ◄Year Specified?►──No──┐│ │

│ │ ││ │

│ Yes ││ │

│ │ ││ │

│ ▼ ││ │

│ ◄Year Matches?►──No────┼┼─┐ │

│ │ │││ │

│ Yes │││ │

│ │ │││ │

│ ▼ │││ │

│ ◄GPA Specified?►──No──┐││││ │

│ │ │││││ │

│ Yes │││││ │

│ │ │││││ │

│ ▼ │││││ │

│ ◄GPA Meets Threshold?►No┼┼┼┼─┐ │

│ │ ││││ │

│ Yes ││││ │

│ │ ││││ │

│ ▼ ││││ │

│ Add to Results ││││ │

│ │ ││││ │
│ │ ┌───────────┘│││ │

│ │ │ │││ │

│ │ │ ┌────────┘││ │

│ │ │ │ ││ │

│ │ │ │ ┌──────┘│ │

│ │ │ │ │ │ │

│ │ │ │ │ ┌────┘ │

│ │ │ │ │ │ │

│ ▼ ▼ ▼ ▼ ▼ │

│ ◄More Resumes to Process?►──Yes──┐ │

│ │ │ │

│ No │ │

│ │ │ │

│ ▼ │ │

│ Sort Results │ │

│ │ │ │

│ ▼ │ │

│ Display Filtered Results │ │

│ │ │ │

│ │ ┌─────────────┘ │

│ │ │ │

│ ▼ ▼ │

│ ◄Export Results?►──No─────────────┐ │

│ │ │ │

│ Yes │ │

│ │ │ │

│ ▼ │ │

│ Select Export Format │ │

│ │ │ │

│ ▼ │ │

│ Generate Export File │ │

│ │ │ │

│ ▼ │ │

│ Download File │ │

│ │ │ │

│ └────────────────────────┘ │

│ │ │

│ ▼ │

│ ■ │

│ │

└─────────────────────────────────────────────────────────────────────┘

These activity diagrams illustrate the procedural flows of the two main system processes: resume
processing and resume filtering. They show the decision points, parallel activities, and the sequential
flow of operations within each process.

4.3 Algorithm & PseudoCode

4.3.1 Algorithm

Algorithm 1: Hybrid Resume Parsing Process

mean_accuracy = 0

count = 0

R_text = extracted text from the resume document

S = {skills, education, experience} // Information sections to extract

// Attempt LLM-based parsing first

For each section s in S:

prompt = construct_specialized_prompt(s, R_text)

LLM_response = call_perplexity_api(prompt)

if (is_valid_response(LLM_response)):

parsed_data[s] = extract_structured_info(LLM_response, s)

section_success[s] = True

else:

section_success[s] = False

// Apply rule-based parsing for failed sections

For each section s in S:

if (section_success[s] == False):

doc = apply_spacy_nlp(R_text)

if (s == "skills"):

parsed_data[s] = extract_skills(R_text, doc)

else if (s == "education"):

parsed_data[s] = extract_education(R_text, doc)

else if (s == "experience"):

parsed_data[s] = extract_experience(R_text, doc)

// Calculate accuracy against ground truth (for evaluation)

For (N), where N = evaluation dataset size

G_i = ground_truth_data for resume i

P_i = parsed_data for resume i

section_accuracy = calculate_section_match(G_i, P_i)

count += 1

// Calculate precision, recall and F1 score

precision = number of correctly extracted items / total extracted items

recall = number of correctly extracted items / total items in ground truth

if (precision + recall > 0):

f1_score = 2 * (precision * recall) / (precision + recall)

else:

f1_score = 0

mean_accuracy = ∑(i=1 to N) section_accuracy / N

The Hybrid Resume Parsing algorithm implements a two-stage approach that combines LLM-based
parsing with traditional rule-based methods. The algorithm begins by initializing accuracy metrics
and extracting text from the input resume document. It then processes three key information
sections: skills, education, and experience.
In the first stage, the algorithm attempts to parse each section using the Perplexity AI language
model. For each section, it constructs a specialized prompt that instructs the LLM on the specific
information to extract and the desired output format. The algorithm then calls the Perplexity API
with this prompt and validates the response. If the LLM successfully extracts structured information
for a section, the algorithm stores this data and marks the section as successfully processed.

For any sections where LLM parsing fails (due to API errors, malformed responses, or other issues),
the algorithm proceeds to the second stage: rule-based parsing. In this stage, the resume text is
processed using the spaCy natural language processing library. Section-specific extraction functions
are applied, using techniques such as regular expression pattern matching, named entity recognition,
and heuristic rules to extract the required information.

The algorithm then evaluates parsing accuracy by comparing the extracted information against
manually labeled ground truth data across an evaluation dataset of N resumes. For each resume, it
calculates section-specific accuracy metrics by matching extracted items against ground truth items.

Finally, the algorithm calculates overall performance metrics: precision (the proportion of extracted
items that are correct), recall (the proportion of ground truth items that were successfully extracted),
and F1 score (the harmonic mean of precision and recall). The mean accuracy across all evaluated
resumes provides a comprehensive measure of the algorithm's performance.

This hybrid approach leverages the semantic understanding capabilities of large language models
while maintaining reliability through rule-based fallback mechanisms, resulting in superior overall
accuracy compared to either approach used in isolation.

Algorithm 2: Multi-Criteria Resume Filtering

Input:

- R = {r₁, r₂, ..., rₙ} // Set of parsed resumes

- S = {s₁, s₂, ..., sₖ} // Set of required skills (if any)

- Y = graduation_year // Required graduation year (if any)

- G = minimum_gpa // Minimum GPA threshold (if any)

Output:

- M = {m₁, m₂, ..., mⱼ} // Set of matching resumes

M = {} // Initialize empty set of matching resumes

For each resume r in R:

match = True // Assume resume matches until proven otherwise

// Check skills criteria

if S is not empty:

resume_skills = lowercase(r.skills)

for each skill s in S:

skill_found = False

for each resume_skill in resume_skills:

if lowercase(s) is contained in resume_skill OR

resume_skill is contained in lowercase(s):

skill_found = True

break

if not skill_found:

match = False

break

// Check graduation year criteria

if Y is not empty AND match is True:

year_match = False

for each edu in r.education:

if edu.graduation_year contains Y:

year_match = True

break

if not year_match:

match = False

// Check GPA criteria

if G is not empty AND match is True:

gpa_match = False

for each edu in r.education:

if edu has gpa AND float(edu.gpa) >= float(G):

gpa_match = True

break

if not gpa_match:
 match = False

// If all criteria match, add to results

if match is True:

add r to M

// Sort results by relevance (optional)

Sort M by number of matching skills in descending order

Return M

The Multi-Criteria Resume Filtering algorithm implements a flexible approach to identifying resumes
that match specific requirements. It takes as input a set of parsed resumes and optional filtering
criteria including required skills, graduation year, and minimum GPA threshold.

The algorithm processes each resume individually, applying the specified filtering criteria in
sequence. First, it checks if the resume contains all the required skills, using case-insensitive
matching and allowing for partial matches to accommodate variations in skill descriptions. Next, if a
graduation year criterion is specified, the algorithm checks if any education entry in the resume
matches the required year. Finally, if a minimum GPA threshold is specified, the algorithm verifies if
any education entry meets or exceeds this threshold.

A resume is added to the matching results only if it satisfies all the specified criteria. If no criteria are
specified for a particular category (skills, year, or GPA), that category is effectively ignored in the
filtering process. After processing all resumes, the algorithm optionally sorts the matching results by
relevance, typically based on the number of matching skills or other relevant metrics.

This algorithm enables efficient and flexible resume filtering, allowing recruiters to quickly identify
candidates whose qualifications match specific job requirements based on the structured
information extracted by the parsing process.

4.3.2 PseudoCode

PseudoCode 1: LLM-Based Parsing with Perplexity AI

Function ParseWithPerplexityAI(resumeText):

// Configure the API request

systemPrompt = "You are a resume parsing expert. Extract the following information from the
resume:

1. Skills: Extract a comprehensive list of all technical and soft skills.

2. Education: Extract all educational qualifications including degree name,

institution name, graduation year, and GPA.

3. Experience: Extract all work experiences including company name,

 position title, time period, and key responsibilities.

Return the information in valid JSON format with three categories:

'skills' (array of strings), 'education' (array of objects),

and 'experience' (array of objects)."

userPrompt = "Parse the following resume and extract skills, education, and experience:\n\n" +
resumeText

payload = {

"model": "sonar",

"messages": [

{"role": "system", "content": systemPrompt},

{"role": "user", "content": userPrompt}

],

"max_tokens": 4000,

"temperature": 0.1,

"top_p": 0.95,

"frequency_penalty": 0

headers = {

"Authorization": "Bearer " + API_KEY,

"Content-Type": "application/json"

Try:

// Make API request

response = HTTPRequest(url="https://api.perplexity.ai/chat/completions",

method="POST",

headers=headers,

body=payload)
 If response.statusCode == 200:

responseData = ParseJSON(response.body)

If responseData contains "choices" AND responseData.choices is not empty:

content = responseData.choices[0].message.content

jsonContent = ExtractJSONFromText(content)

Try:

parsedData = ParseJSON(jsonContent)

Return {

"skills": parsedData.skills OR [],

"education": parsedData.education OR [],

"experience": parsedData.experience OR []

Catch JSONParseError:

LogError("Error parsing JSON from Perplexity response")

Return null

Else:

LogError("Unexpected response format from Perplexity API")

Return null

Else:

LogError("Perplexity API request failed with status code: " + response.statusCode)

Return null

Catch Exception as e:

LogError("Error calling Perplexity API: " + e.message)

Return null

Function ExtractJSONFromText(text):

// Try to extract JSON content from text that might contain markdown or explanations
 // First, try to extract content between json code blocks

jsonMatch = Regex.Search("```(?:json)?(.*)```", text, DOTALL)

If jsonMatch:

Return jsonMatch.group(1).trim()

// Next, try to extract any JSON object in the text

jsonMatch = Regex.Search("(\{[\s\S]*\})", text)

If jsonMatch:

Return jsonMatch.group(1)

// If no JSON structure found, return the original text

Return text

PseudoCode 2: Rule-Based Skills Extraction

Function ExtractSkills(resumeText, nlpDoc):

skills = []

// Define common technical skills to look for

technicalSkills = [

"Python", "Java", "JavaScript", "C++", "C#", "Ruby", "PHP", "Swift", "Kotlin",

"HTML", "CSS", "React", "Angular", "Vue.js", "Node.js", "Express", "Django",

"jQuery", "Bootstrap", "REST API", "GraphQL", "SQL", "MySQL", "PostgreSQL",

"MongoDB", "Oracle", "SQLite", "Redis", "AWS", "Azure", "Google Cloud",

"Docker", "Kubernetes", "Git", "GitHub", "GitLab", "Jenkins", "CI/CD",

"TensorFlow", "PyTorch", "Machine Learning", "Deep Learning", "AI",

"Data Analysis", "Data Science", "NLP", "Computer Vision"

// Define common soft skills to look for

softSkills = [

"Leadership", "Communication", "Teamwork", "Problem-Solving", "Critical Thinking",

 "Time Management", "Project Management", "Creativity", "Adaptability", "Organization",

"Presentation", "Collaboration", "Analytical", "Detail-Oriented", "Strategic Thinking"

// Try to find explicit skills sections

skillsSectionPattern = "(?:SKILLS|SKILLS & INTERESTS|TECHNICAL SKILLS|PROFESSIONAL SKILLS)[^\

n]\n(.?)(?:^#|^##|^[A-Z\s]{2,}|\Z)"

skillsMatch = Regex.Search(skillsSectionPattern, resumeText, MULTILINE | DOTALL | IGNORECASE)

If skillsMatch:

skillsText = skillsMatch.group(1)

// Look for skills in category format: "Languages: Python, Java, C++"

categorySkills = Regex.FindAll("([A-Za-z\s]+):([^•#]+)", skillsText)

For each (category, categorySkillsText) in categorySkills:

For each skill in Split(categorySkillsText, ",|\n|•"):

skill = skill.trim()

If skill is not empty AND skill.length > 1 AND skill not in skills:

Add skill to skills

// Look for skills in bullet format: "• Python • Java • C++"

bulletSkills = Regex.FindAll("•\s*([^•\n]+)", skillsText)

For each skill in bulletSkills:

skill = skill.trim()

If skill is not empty AND skill.length > 1 AND skill not in skills:

Add skill to skills

// Scan the entire document for common skills

textLower = resumeText.toLowerCase()

For each skill in (technicalSkills + softSkills):

skillLower = skill.toLowerCase()
 If Regex.Search("\b" + Regex.Escape(skillLower) + "\b", textLower) AND skill not in skills:

Add skill to skills

Return skills

PseudoCode 3: Rule-Based Education Extraction

Function ExtractEducation(resumeText, nlpDoc):

education = []

// Find education section

educationSectionPattern = "(?:EDUCATION|ACADEMIC BACKGROUND)[^\n]\n(.?)(?:^#|^##|^[A-Z\

s]{2,}|\Z)"

educationMatch = Regex.Search(educationSectionPattern, resumeText, MULTILINE | DOTALL |

IGNORECASE)

If educationMatch:

educationText = educationMatch.group(1)

// Look for education entries in format: "University Name, Degree • Details"

universityEntries = Regex.FindAll("([^\n•#]+)(?:•|\*|\-)([^\n•#]+)", educationText)

For each (university, details) in universityEntries:

// Extract GPA if present

gpaMatch = Regex.Search("GPA\s*:\s*([\d\.]+)", details, IGNORECASE)

gpa = gpaMatch ? gpaMatch.group(1) : null

// Extract graduation date if present

graduationDateMatch = Regex.Search("(?:Graduated|Graduation)\s*:\s*(\d{4})", details,

IGNORECASE)

graduationYear = graduationDateMatch ? graduationDateMatch.group(1) : null

// Create structured education entry

educationEntry = {

"institution": university.trim(),
 "details": details.trim(),

"gpa": gpa,

"graduation_year": graduationYear

Add educationEntry to education

// If no entries found with above pattern, try extracting lines

If education is empty:

For each line in Split(educationText, "\n"):

line = line.trim()

If line is not empty AND not line.startsWith('#') AND not line.startsWith('##'):

Add line to education

// If still no education found, try to find education-related entities

If education is empty:

For each entity in nlpDoc.entities:

If entity.label == "ORG" AND entity.text.toLowerCase() contains any of

["university", "college", "school", "institute"]:

// Find the sentence containing this entity

For each sentence in nlpDoc.sentences:

If entity is within sentence:

Add sentence.text.trim() to education

Break

Return education

PseudoCode 4: Rule-Based Experience Extraction

Function ExtractExperience(resumeText, nlpDoc):

experience = []
 // Define section patterns to search for

sections = [

("EXPERIENCE", "(?:EXPERIENCE|WORK EXPERIENCE|PROFESSIONAL EXPERIENCE)[^\n]\n(.?)

(?:^#|^##|^[A-Z\s]{2,}|\Z)"),

("PROJECTS", "(?:PROJECTS|PROJECT EXPERIENCE)[^\n]\n(.?)(?:^#|^##|^[A-Z\s]{2,}|\Z)"),

("INTERNSHIPS", "(?:INTERNSHIPS|INTERNSHIP EXPERIENCE)[^\n]\n(.?)(?:^#|^##|^[A-Z\s]{2,}|\

Z)")

For each (sectionName, pattern) in sections:

sectionMatch = Regex.Search(pattern, resumeText, MULTILINE | DOTALL | IGNORECASE)

If sectionMatch:

sectionText = sectionMatch.group(1)

// Look for entries in format: "Company/Project Name • Description"

entries = Regex.FindAll("([^\n•#]+)(?:•|\*|\-)([^\n•#]+)", sectionText)

For each (name, description) in entries:

// Try to extract dates if present

dateMatch = Regex.Search("((?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec|
January|February|March|April|May|June|July|August|September|October|November|December)
[\s,]*\d{4})\s*(?:-|to|–|until)\s*((?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec|
January|February|March|April|May|June|July|August|September|October|November|December)
[\s,]*\d{4}|Present|Current)", description, IGNORECASE)

dateInfo = dateMatch ? dateMatch.group(0) : null

// Create structured experience entry

experienceEntry = {

"company": name.trim(),

"description": description.trim(),

"date": dateInfo

}
 Add experienceEntry to experience

// If no entries found with above pattern, try alternative approach

If entries is empty:

currentEntry = ""

For each line in Split(sectionText, "\n"):

line = line.trim()

If line is not empty AND not line.startsWith('#') AND not line.startsWith('##'):

If Regex.Match("^[A-Z]", line) AND currentEntry is not empty:

// New entry starts with capital letter

Add {"description": currentEntry} to experience

currentEntry = line

Else:

If currentEntry is not empty:

currentEntry += " " + line

Else:

currentEntry = line

// Add the last entry if exists

If currentEntry is not empty:

Add {"description": currentEntry} to experience

Return experience

PseudoCode 5: Resume Filtering Algorithm

Function FilterResumes(parsedResumes, filterCriteria):

filteredResumes = []

// Extract filter criteria

requiredSkills = filterCriteria.skills || []

graduationYear = filterCriteria.year || ""

gpaThreshold = filterCriteria.gpa || ""

For each resume in parsedResumes:

// Initialize match flags

skillsMatch = requiredSkills.length == 0 // True if no skills specified

yearMatch = graduationYear == "" // True if no year specified

gpaMatch = gpaThreshold == "" // True if no GPA specified

// Check skill requirements

If not skillsMatch:

resumeSkills = [skill.toLowerCase() for each skill in resume.skills]

allSkillsFound = true

For each skill in requiredSkills:

skillFound = false

skillLower = skill.toLowerCase()

For each resumeSkill in resumeSkills:

If resumeSkill contains skillLower OR skillLower contains resumeSkill:

skillFound = true

Break

If not skillFound:

allSkillsFound = false

Break

skillsMatch = allSkillsFound

// Check graduation year requirement

If not yearMatch AND skillsMatch:

For each edu in resume.education:

 If typeof edu is dictionary AND "graduation_year" in edu:

If edu.graduation_year contains graduationYear:

yearMatch = true

Break

// Check GPA threshold requirement

If not gpaMatch AND skillsMatch AND yearMatch:

For each edu in resume.education:

If typeof edu is dictionary AND "gpa" in edu AND edu.gpa is not null:

If ParseFloat(edu.gpa) >= ParseFloat(gpaThreshold):

gpaMatch = true

Break

// Add resume to results if all criteria match

If skillsMatch AND yearMatch AND gpaMatch:

Add {

"id": resume.id,

"name": resume.filename,

"skills": resume.skills,

"education": resume.education,

"experience_count": Length(resume.experience)

} to filteredResumes

// Sort results by relevance (optional)

Sort filteredResumes by number of matching skills in descending order

Return filteredResumes

These pseudocode implementations provide detailed algorithmic descriptions of the key components
of the LLM-Powered Resume Parser system. They illustrate the specific steps and logic used in the
LLM-based parsing, rule-based fallback parsing for different information categories, and the resume
filtering process. The pseudocode is written in a language-agnostic manner while maintaining the
essential logic and flow of the actual implementation.
4.4 Module Description

4.4.1 Document Processing Module

The Document Processing Module is responsible for handling various document formats and
extracting text content for further processing. This module acts as the entry point for resume
documents, performing format-specific extraction and text normalization.

Functions and Responsibilities:

1. Format Detection

 Identifies document type based on file extension

 Validates file format against supported types (PDF, DOCX, images)

 Routes documents to appropriate processors

2. PDF Processing

 Uses PyPDF2 to extract text from PDF documents

 Preserves document structure where possible

 Handles multi-page documents by concatenating content

 Processes embedded text and basic formatting

3. DOCX Processing

 Leverages python-docx for Word document text extraction

 Preserves paragraph boundaries and basic formatting

 Extracts embedded tables and lists

 Maintains document structure for improved parsing

4. Image Processing

 Implements OCR using pytesseract for image-based resumes

 Preprocesses images to improve OCR quality (deskewing, contrast enhancement)

 Handles various image formats (JPG, PNG)

 Attempts to preserve document layout during OCR

5. Text Normalization

 Cleans extracted text by removing control characters and irrelevant symbols

 Normalizes whitespace and line breaks

 Standardizes bullet points and list markers

 Identifies and enhances section headers

 Corrects common OCR errors through pattern matching

Interfaces:
  Input: Resume document file (PDF, DOCX, or image)

 Output: Normalized text content with preserved structure

 External Dependencies: PyPDF2, python-docx, pytesseract, Pillow

Error Handling:

 Graceful degradation for partially unreadable documents

 Specific error messages for different extraction issues

 Fallback extraction methods for challenging documents

This module serves as the foundation for the parsing process, ensuring that regardless of the original
document format, the system has quality text content to work with. Its effectiveness directly impacts
the performance of downstream parsing operations.

4.4.2 Parsing Engine Module

The Parsing Engine Module forms the core of the LLM-Powered Resume Parser, implementing the
hybrid parsing approach that combines LLM-based semantic understanding with rule-based
reliability. This module is responsible for extracting structured information from the normalized text
provided by the Document Processing Module.

Components:

1. Parser Controller

 Orchestrates the parsing workflow

 Determines which parsing approach to use for each section

 Implements the fallback logic when primary parsing fails

 Combines results from different parsing methods

 Ensures consistent output format regardless of parsing method

2. LLM Parser

 Constructs specialized prompts for Perplexity AI

 Manages API communication with authentication

 Processes API responses to extract structured information

 Handles JSON extraction from natural language responses

 Implements error handling for API failures

3. Rule-Based Parser

 Processes text using spaCy NLP pipeline

 Implements section identification using regular expressions

 Extracts entities using named entity recognition

 Applies pattern matching for skills, education, and experience

  Uses predefined rules and dictionaries for information extraction

4. Section Identifier

 Identifies major resume sections (skills, education, experience)

 Uses both pattern matching and contextual analysis

 Handles variations in section headers and organization

 Provides section boundaries for targeted parsing

5. Information Structuring

 Standardizes extracted information into consistent format

 Normalizes variations in terminology and formatting

 Organizes information into hierarchical relationships

 Ensures output conforms to defined schema

Processing Flow:

1. Normalized text is passed to the Section Identifier

2. For each identified section: a. Parser Controller attempts LLM-based parsing b. If successful,
structured information is extracted and validated c. If unsuccessful, Rule-Based Parser is
applied to that section

3. Results from all sections are combined into a unified structure

4. Final validation ensures output completeness and format consistency

Performance Considerations:

 Section-by-section processing allows for targeted parsing and efficient fallback

 API caching reduces redundant calls for similar content

 Selective application of LLM parsing based on section complexity

 Confidence scoring for extracted information

Error Handling:

 Comprehensive exception handling for API communication

 Validation of LLM responses before processing

 Graceful degradation through rule-based fallbacks

 Detailed logging of parsing failures for analysis

The Parsing Engine Module embodies the key innovation of the system: the integration of advanced
language model capabilities with traditional parsing techniques in a complementary architecture.
This hybrid approach enables the system to achieve high accuracy while maintaining reliability,
addressing the fundamental challenge of resume parsing.

4.4.3 Storage and Filtering Module

The Storage and Filtering Module manages data persistence and search capabilities within the LLM-
Powered Resume Parser. This module handles the storage of both original documents and parsed
information, along with the implementation of filtering functionality to search across processed
resumes.

Components:

1. File Storage Manager

 Handles storage of original resume documents

 Implements unique naming scheme based on timestamps

 Manages directory structure for organized storage

 Provides access controls and validation for file operations

2. Data Storage Manager

 Stores parsed resume information in JSON format

 Maintains consistent data schema across stored records

 Links parsed data to original documents through naming conventions

 Provides efficient access patterns for retrieval operations

3. Query Engine

 Implements search and filtering functionality

 Processes multi-criteria queries (skills, education, experience)

 Performs case-insensitive and partial matching for flexible searching

 Supports complex boolean operations (AND/OR logic)

4. Filter Controller

 Provides API endpoints for filtering operations

 Processes filter requests from the web interface

 Validates and normalizes filter criteria

 Returns formatted results to the presentation layer

Storage Structure:

1. File Organization

 /uploads/: Directory for original documents

 Naming pattern: YYYYMMDD_HHMMSS_originalfilename.ext

 /parsed_data/: Directory for parsed information

 Naming pattern: YYYYMMDD_HHMMSS_originalfilename.json

2. JSON Schema
  Standard format for all parsed resumes:

3. {

4. "filename": "original_filename.pdf",

5. "parsed_data": {

6. "skills": ["Python", "Java", ...],

7. "education": [

8. {

9. "institution": "University Name",

10. "degree": "Degree Name",

11. "graduation_year": "2022",

12. "gpa": "3.8"

13. }

14. ],

15. "experience": [

16. {

17. "company": "Company Name",

18. "position": "Position Title",

19. "description": "Job description",

20. "date": "Date information"

21. }

22. ]

23. }

24. }

Filtering Capabilities:

1. Skills Filtering

 Multi-select skill requirements

 Case-insensitive matching

 Partial matching for skill variations

 AND/OR logic for skill combinations

2. Education Filtering

 Graduation year filtering

  Minimum GPA threshold

 Degree type matching

 Institution filtering

3. Result Handling

 Sorting by relevance or other criteria

 Pagination for large result sets

 Summary statistics for result counts

 Export functionality for filtered results

Performance Optimizations:

 In-memory caching for frequently accessed data

 Efficient query execution through indexing

 Batch processing for large-scale operations

 Asynchronous processing for non-blocking operation

The Storage and Filtering Module provides the persistent data management and search capabilities
that enable the system to function as a practical recruitment tool. By maintaining structured
information and providing powerful filtering capabilities, this module transforms the parsing
functionality into a usable application for candidate matching and selection.

4.5 Steps to execute/run/implement the project

4.5.1 Installation and Setup

Prerequisites:

 Python 3.9 or higher

 pip (Python package manager)

 Virtual environment (recommended)

 Perplexity AI API key

Environment Setup:

1. Clone the repository:

2. Copygit clone https://github.com/username/llm-powered-resume-parser.git

3. cd llm-powered-resume-parser

4. Create and activate a virtual environment:

5. Copypython -m venv venv

6.

7. # On Windows
 8. venv\Scripts\activate

9.

10. # On macOS/Linux

11. source venv/bin/activate

12. Install dependencies:

13. Copypip install -r requirements.txt

14. Install spaCy language model:

15. Copypython -m spacy download en_core_web_sm

16. Set up environment variables:

17. Copy# On Windows

18. set PERPLEXITY_API_KEY=your_api_key_here

19.

20. # On macOS/Linux

21. export PERPLEXITY_API_KEY=your_api_key_here

22. Create required directories:

23. Copymkdir -p uploads parsed_data

4.5.2 Running the Application

Development Mode:

1. Start the Flask development server:

2. Copypython app.py

3. Access the application: Open a web browser and navigate to http://127.0.0.1:5000

Production Deployment:

1. Set up Gunicorn (Linux/macOS):

2. Copygunicorn -w 4 -b 0.0.0.0:8000 app:app

3. Configure NGINX as reverse proxy: Create an NGINX configuration file:

4. Copyserver {

5. listen 80;

6. server_name yourserver.com;

7.

8. location / {

9. proxy_pass http://127.0.0.1:8000;
 10. proxy_set_header Host $host;

11. proxy_set_header X-Real-IP $remote_addr;

12. }

13. }

14. Using Docker:

15. Copy# Build the Docker image

16. docker build -t resume-parser .

17.

18. # Run the container

19. docker run -p 8000:8000 -e PERPLEXITY_API_KEY=your_api_key_here resume-parser

4.5.3 Configuration and Customization

Application Configuration:

1. Modify config.py for application settings:

2. Copy# Flask application settings

3. DEBUG = False

4. MAX_CONTENT_LENGTH = 16 * 1024 * 1024 # 16MB max upload size

5.

6. # API Configuration

7. API_TIMEOUT = 30 # seconds

8. MAX_RETRIES = 3

9.

10. # Parser Configuration

11. USE_LLM = True

12. LLM_CONFIDENCE_THRESHOLD = 0.7

13. Customize the parser behavior:

 Edit resume_parser/model.py to modify parsing logic

 Adjust prompt templates in templates/prompts/

 Modify regular expressions in resume_parser/patterns.py

14. Add custom skills to the skills dictionary: Edit resume_parser/skills_dictionary.py to add
domain-specific skills:

15. CopyCUSTOM_SKILLS = [
 16. # Industry-specific skills

17. "Blockchain", "Smart Contracts", "Solidity",

18. # Role-specific skills

19. "Market Research", "Competitive Analysis"

20. ]

User Interface Customization:

1. Modify the templates:

 Edit HTML templates in the templates/ directory

 Customize CSS in static/css/styles.css

 Modify JavaScript functionality in static/js/

2. Change the filter criteria: Edit templates/filter.html to add or modify filter options:

3. Copy<div class="filter-section">

4. <h2>Additional Filters</h2>

5. <label>

6. <input type="checkbox" name="recent-grads-only">

7. Recent Graduates Only (Last 2 Years)

8. </label>

9. </div>

Testing:

1. Run unit tests:

2. Copypytest tests/

3. Run integration tests:

4. Copypytest tests/integration/

5. Test with sample resumes:

6. Copypython scripts/test_parser.py --file=samples/sample_resume.pdf

By following these steps, you can set up, run, and customize the LLM-Powered Resume Parser to suit
your specific requirements. The system's modular design allows for flexible configuration and
extension of functionality without requiring changes to the core architecture.

5. IMPLEMENTATION AND TESTING

5.1 Input and Output

5.1.1 Input Design

The LLM-Powered Resume Parser accepts inputs in several formats, with specific design
considerations for each input type:

1. Resume Document Input

The primary input to the system is the resume document, which is accepted in multiple formats:

 PDF Files:

 Format: Adobe Portable Document Format (.pdf)

 Size Limit: 16MB

 Validation: MIME type checking to ensure authentic PDF files

 Handling: Direct text extraction using PyPDF2

 Word Documents:

 Format: Microsoft Word (.docx)

 Size Limit: 16MB

 Validation: MIME type verification

 Handling: Structured text extraction with python-docx

 Image Files:

 Formats: JPEG, PNG (.jpg, .jpeg, .png)

 Size Limit: 16MB

 Validation: Image format verification

 Handling: OCR processing using pytesseract

2. Upload Interface Design

The web interface for document upload is designed for usability and error prevention:

 Drag-and-Drop Area:

 Visual indication of dropzone with dashed border

 Animated feedback on drag events

 Clear visual feedback on file acceptance

 File Browser Button:

 Alternative method for users who prefer traditional file selection

 Filters for accepted file types in file browser dialog

 Validation Feedback:

 Real-time validation of file type

 Clear error messages for invalid files

  Progress indicator during upload

 Submission Control:

 Upload button disabled until valid file is selected

 Confirmation before processing begins

 Cancel option during upload

3. Filtering Input Design

The system accepts filtering criteria through a structured interface:

 Skills Selection:

 Multi-select interface with checkboxes

 Searchable skill list with autocomplete

 Categorized display of common skills

 Custom skill input option

 Education Filters:

 Graduation year selection via dropdown

 GPA threshold input via radio buttons with predefined ranges

 Degree type selection (optional)

 Input Validation:

 Client-side validation for format correctness

 Server-side validation for security

 Informative error messages for invalid inputs

4. API Input Design

For programmatic access, the system exposes API endpoints with structured input requirements:

 Upload API:

 Method: POST

 Content-Type: multipart/form-data

 Required fields: 'file' (the resume document)

 Optional parameters: 'use_llm' (boolean)

 Filter API:

 Method: POST

 Content-Type: application/json

 JSON structure:
  Copy{

 "skills": ["Python", "Java"],

 "year": "2022",

 "gpa": "3.5"

 }

 All filter criteria are optional

Input Validation and Error Handling

All inputs are validated both client-side and server-side:

 File type validation through MIME type checking

 File size limitations to prevent resource exhaustion

 Input sanitization to prevent injection attacks

 Comprehensive error messages for invalid inputs

 Graceful handling of unexpected input formats

The input design prioritizes usability, accessibility, and error prevention while ensuring the system
receives high-quality inputs for processing. This approach maximizes the chances of successful
parsing while providing clear feedback when issues arise.

5.1.2 Output Design

The LLM-Powered Resume Parser produces several types of outputs, each designed for optimal
usability and information communication:

1. Parsed Resume Data Structure

The core output of the system is the structured resume information, organized in a consistent JSON
format:

Copy{

"skills": [

"Python",

"Machine Learning",

"Data Analysis",

"JavaScript",

"SQL"

],

"education": [

{
 "institution": "Stanford University",

"degree": "Master of Science in Computer Science",

"graduation_year": "2021",

"gpa": "3.9"

},

"institution": "University of California, Berkeley",

"degree": "Bachelor of Science in Computer Engineering",

"graduation_year": "2019",

"gpa": "3.7"

],

"experience": [

"company": "Tech Innovations Inc.",

"position": "Senior Software Engineer",

"date": "January 2022 - Present",

"description": "Led development of machine learning algorithms for product recommendation

engine, improving conversion rates by 35%."

},

"company": "Data Solutions LLC",

"position": "Software Developer",

"date": "June 2019 - December 2021",

"description": "Developed data processing pipelines using Python and SQL, handling over 500GB
of customer data daily."

This structured format enables:

 Consistent data representation across different resume formats

 Easy integration with other systems

  Efficient filtering and searching

 Clear separation of information categories

2. Results Display Interface

The parsed information is presented to users through a clean, organized interface:

 Skills Section:

 Visual grouping of related skills

 Categorization of technical vs. soft skills

 Prominence based on relevance/importance

 Tag-based visualization for quick scanning

 Education Section:

 Chronological organization (most recent first)

 Visual hierarchy highlighting institution and degree

 Structured presentation of dates and performance metrics

 Visual indicators for degree levels

 Experience Section:

 Timeline-based visualization

 Company and position prominence

 Structured formatting of responsibilities

 Visual distinction between roles and companies

 Navigation and Controls:

 Section quick-jump links

 Expandable/collapsible sections

 Print/export options

 Return to upload button

3. Filtering Results Output

When users apply filters, the system produces a specialized output format:

 List View:

 Compact summary of matching resumes

 Highlight of matching criteria

 Preview of key qualifications

 Visual indication of match strength

  Detail View:

 Expanded information for selected resume

 Highlighting of matched filter criteria

 Context around matched elements

 Compare option for multiple resumes

 Aggregated Statistics:

 Count of matching resumes

 Distribution of skills across results

 Education level breakdown

 Experience range summary

4. API Response Format

For programmatic access, the API endpoints return structured responses:

 Parsing Result API:

 Copy{

 "success": true,

 "filename": "original_filename.pdf",

 "parsed_data": {

 "skills": [...],

 "education": [...],

 "experience": [...]

 },

 "confidence_scores": {

 "skills": 0.92,

 "education": 0.95,

 "experience": 0.88

 }

 }

 Filter API Response:

 Copy{

 "count": 5,

 "results": [
  {

 "id": "20230615_123045_resume.json",

 "name": "resume.pdf",

 "skills": [...],

 "education": [...],

 "experience_count": 3,

 "match_score": 0.89

 },

 ...

 ]

 }

5. Error Output Design

When errors occur, the system provides structured error information:

 User-Facing Errors:

 Clear, non-technical error messages

 Suggested actions to resolve the issue

 Visual distinction from normal content

 Error categorization (upload error, parsing error, etc.)

 API Error Responses:

 Copy{

 "success": false,

 "error": {

 "code": "invalid_file_type",

 "message": "The uploaded file is not a supported format. Please upload PDF, DOCX, or
image files.",

 "details": {

 "file_type": "application/xml",

 "supported_types": ["application/pdf", "application/vnd.openxmlformats-

officedocument.wordprocessingml.document", "image/jpeg", "image/png"]

 }

 }

 }
The output design focuses on clarity, organization, and usability, ensuring that the valuable
information extracted from resumes is presented in the most effective way for different user needs.
The consistent structure enables both human readability and programmatic processing, making the
system versatile for various use cases.

5.2 Testing

5.2.1 Testing Strategies

The LLM-Powered Resume Parser was tested using a comprehensive multi-level approach to ensure
functionality, reliability, and performance across various scenarios:

1. Unit Testing

Unit tests focused on verifying the correct behavior of individual components in isolation:

 Framework: pytest

 Coverage Target: >80% code coverage

 Key Areas Tested:

 Text extraction from different file formats

 LLM prompt construction

 JSON extraction from LLM responses

 Rule-based parsing functions

 Filter matching logic

Example Unit Test for JSON Extraction:

Copydef test_extract_json_from_text():

# Test with well-formed JSON response

sample_text = """Here's the extracted information:

"skills": ["Python", "Machine Learning", "Data Analysis"],

"education": [{"institution": "MIT", "degree": "BS Computer Science", "graduation_year":

"2020"}],

"experience": [{"company": "Tech Corp", "position": "Developer", "date": "2020-2022"}]

}"""

parser = ResumeParserModel()

result = parser._extract_json_from_text(sample_text)

parsed_json = json.loads(result)
 assert "skills" in parsed_json

assert "Python" in parsed_json["skills"]

assert len(parsed_json["education"]) == 1

assert parsed_json["education"][0]["institution"] == "MIT"

2. Integration Testing

Integration tests verified the correct interaction between components:

 Framework: pytest with Flask test client

 Approach: End-to-end workflow testing

 Key Workflows Tested:

 Document upload and processing pipeline

 LLM API integration

 Storage and retrieval operations

 Filtering functionality

Example Integration Test:

Copydef test_resume_upload_and_parsing():

app = create_test_app()

client = app.test_client()

# Create test PDF file

test_file_path = create_test_resume_pdf()

# Mock the Perplexity API response

with patch('requests.post') as mock_post:

mock_post.return_value.status_code = 200

mock_post.return_value.json.return_value = {

'choices': [{

'message': {

'content': '{"skills": ["Python", "Data Analysis"], "education": [{"institution": "Test

University", "degree": "BS", "graduation_year": "2020", "gpa": "3.8"}], "experience": [{"company":
"Test Company", "position": "Developer", "date": "2020-2022", "description": "Developed
applications"}]}'

}
 }]

# Test file upload and processing

with open(test_file_path, 'rb') as test_file:

response = client.post(

'/upload',

data={'file': (test_file, 'test_resume.pdf')},

content_type='multipart/form-data'

# Verify redirect to results page

assert response.status_code == 302

assert 'results?filename=' in response.location

3. System Testing

System tests evaluated the complete system behavior:

 Methodology: Manual and automated system-level testing

 Environment: Testing across multiple browsers and devices

 Key Aspects Tested:

 Cross-browser compatibility

 Mobile responsiveness

 Error handling and recovery

 End-to-end user workflows

Test Cases:

1. Upload various resume formats (PDF, DOCX, image) and verify correct parsing

2. Test with complex layouts, multi-column formats, and creative designs

3. Upload large files approaching size limits to verify handling

4. Test filter functionality with various criteria combinations

5. Verify error handling for invalid files and formats

6. Test system behavior under concurrent user access

4. Performance Testing
Performance testing evaluated system efficiency and scalability:

 Tools: Locust for load testing, cProfile for performance profiling

 Metrics: Response times, throughput, resource utilization

 Scenarios Tested:

 Single user performance

 Concurrent user scenarios (5, 10, 20 users)

 Batch processing of multiple resumes

Test Results:

 Average parsing time: 7.5 seconds per resume

 Maximum concurrent users with acceptable performance: 15

 CPU utilization under peak load: 75%

 Memory usage: 250MB baseline + ~15MB per active parsing task

5. Security Testing

Security testing focused on identifying vulnerabilities:

 Methodology: Combination of automated scanning and manual testing

 Areas Tested:

 Input validation and sanitization

 File upload security

 API authentication and authorization

 Error handling information disclosure

Key Tests:

1. Attempted upload of malicious file types disguised as PDFs

2. Testing for path traversal vulnerabilities in file handling

3. Verification of proper API key protection

4. Testing for information leakage in error responses

6. Usability Testing

Usability testing evaluated the user experience:

 Participants: 8 HR professionals with various technical backgrounds

 Methodology: Task-based testing with observation

 Tasks Included:

 Uploading various resume formats

  Interpreting parsing results

 Applying filters to find specific candidates

 Handling error scenarios

Feedback Highlights:

 Intuitive upload interface (rated 4.5/5)

 Clear presentation of parsing results (rated 4.2/5)

 Filter functionality effectiveness (rated 4.3/5)

 Error message clarity (rated 3.9/5)

7. Regression Testing

Regression testing ensured new changes didn't break existing functionality:

 Automation: CI/CD pipeline with automated test suite

 Coverage: Core functionality and critical user flows

 Frequency: Run on every code push and nightly builds

The comprehensive testing approach verified that the LLM-Powered Resume Parser met its
functional requirements while maintaining performance, security, and usability standards. Testing
revealed several opportunities for improvement, particularly in error handling and parsing of
complex document layouts, which were addressed in subsequent development iterations.

5.2.2 Performance Evaluation

The performance of the LLM-Powered Resume Parser was systematically evaluated to assess its
accuracy, efficiency, and scalability in real-world usage scenarios.

Test Environment:

 Hardware: AWS EC2 t3.large instance (2 vCPU, 8GB RAM)

 Operating System: Ubuntu 20.04 LTS

 Python Version: 3.9.12

 Database: File-based storage

 Network: Dedicated 1Gbps connection for API calls

 Test Corpus: 100 diverse resumes (40 PDF, 40 DOCX, 20 images)

Evaluation Metrics:

1. Accuracy Metrics

 Precision: Correctness of extracted information

 Recall: Completeness of extracted information

 F1 Score: Harmonic mean of precision and recall

 2. Efficiency Metrics

 Processing Time: Time to parse a single resume

 Throughput: Number of resumes processed per hour

 Resource Utilization: CPU, memory, and network usage

3. Scalability Metrics

 Concurrent User Capacity: Maximum users with acceptable performance

 Linear Scaling Factor: Performance degradation with increased load

 Recovery Time: System recovery after peak loads

Test Methodology:

1. Accuracy Testing

 Manual labeling of 100 test resumes by HR professionals

 Comparison of system output against labeled ground truth

 Calculation of precision, recall, and F1 score for each information category

 Cross-validation across different resume formats and styles

2. Efficiency Testing

 Measurement of processing times across different resume formats

 Profiling of resource utilization during parsing operations

 Identification of performance bottlenecks through code profiling

 API response time analysis for different operation types

3. Scalability Testing

 Simulated concurrent user loads (5, 10, 15, 20, 25 users)

 Measurement of response times and success rates under load

 Evaluation of system stability during extended operation

 Testing of recovery after simulated component failures

Performance Results:

1. Accuracy Results

Information Category Precision Recall F1 Score

Skills 93.4% 89.1% 91.2%

Education 94.7% 92.9% 93.8%

Information Category Precision Recall F1 Score

Experience 87.9% 90.2% 89.0%

Overall 92.0% 90.7% 91.3%

2. Processing Time by Document Type

Format Average Time (sec) Min Time (sec) Max Time (sec)

Standard PDF 5.2 3.1 8.7

Complex PDF 7.8 5.3 12.2

DOCX 4.3 2.8 7.1

Image
12.6 9.4 18.3
(JPG/PNG)

Overall 7.5 2.8 18.3

3. Resource Utilization

Operation CPU Usage (%) Memory Usage (MB) Network I/O (KB)

PDF Processing 35% 180 15

DOCX Processing 30% 150 12

Image
65% 320 25
Processing

LLM API Call 15% 60 180

Filter Operation 25% 120 30

4. Scalability Results
 Concurrent Avg. Response Time Success Rate Throughput
Users (sec) (%) (resumes/hour)

1 7.5 100% 480

5 8.2 100% 2196

10 9.8 98.5% 3673

15 12.3 96.7% 4390

20 18.7 92.1% 3841

25 27.5 85.3% 2792

Performance Analysis:

1. Accuracy Analysis

 The hybrid parsing approach achieved over 90% F1 score overall, with education
information extracted most accurately (93.8% F1)

 Experience information showed the lowest accuracy (89.0% F1), primarily due to
variability in description formatting

 LLM parsing alone achieved 89.2% F1, while rule-based parsing achieved 82.9% F1,
demonstrating the effectiveness of the hybrid approach

2. Efficiency Analysis

 Average processing time of 7.5 seconds per resume meets the target of < 10 seconds

 Image-based resumes required significantly more processing time due to OCR

operations

 API calls accounted for approximately 40% of total processing time

 Memory usage remained within acceptable limits, with peak usage during image
processing

3. Scalability Analysis

 System maintained acceptable performance up to 15 concurrent users

 Beyond 15 users, response times increased exponentially and success rates declined

 Throughput peaked at 15 concurrent users, then decreased due to resource

contention

 The system showed good recovery characteristics after peak loads

Performance Optimization Opportunities:

1. Processing Time Improvements

 Implement document section caching to avoid redundant processing

 Optimize OCR operations for image-based resumes

 Implement asynchronous processing for parallel operations

 Add request queuing for better load management

2. Accuracy Enhancements

 Improve experience section parsing through enhanced pattern recognition

 Add domain-specific training for specialized industries

 Implement confidence scoring for extracted information

3. Scalability Enhancements

 Implement horizontal scaling for document processing

 Add API request batching to reduce network overhead

 Optimize database operations for concurrent access

 Implement more efficient resource allocation

The performance evaluation demonstrated that the LLM-Powered Resume Parser meets its primary
functional and performance requirements, with particularly strong results in education information
extraction and processing of structured document formats. The system shows good performance
characteristics for typical usage scenarios, with clear paths for optimization to handle higher loads
and improve processing times for image-based documents.

6. RESULTS AND DISCUSSIONS

6.1 Efficiency of the Proposed System

The LLM-Powered Resume Parser demonstrates significant efficiency improvements over traditional
parsing approaches in several key dimensions.

Parsing Accuracy and Reliability

The hybrid parsing architecture combines the semantic understanding of large language models with
the reliability of rule-based approaches, resulting in superior overall performance. This efficiency is
evident in the system's ability to extract structured information with high accuracy across diverse
resume formats:

 Overall Accuracy: 91.3% F1 score across all information categories and resume formats

 Fallback Reliability: 94.2% successful recovery rate when LLM parsing fails

 Format Adaptability: Consistent performance across standard (93.7% accuracy) and non-
standard formats (88.4% accuracy)
This balanced approach addresses the fundamental efficiency challenge in resume parsing:
maintaining high accuracy while ensuring reliable operation across diverse document formats.

Processing Efficiency

The system demonstrates efficient resource utilization while maintaining reasonable processing
times:

 Average Processing Time: 7.5 seconds per resume, well below the 10-second target

 Resource Utilization: Moderate CPU (35-65%) and memory (150-320MB) usage during
parsing

 Throughput: Approximately 480 resumes per hour on a single instance

 API Efficiency: Structured prompts minimize token usage and optimize API costs

These efficiency metrics indicate that the system can process substantial resume volumes while
maintaining acceptable performance and resource consumption.

Operational Efficiency

From an operational perspective, the system offers several efficiency advantages:

 Error Handling: Graceful degradation ensures partial results even when full parsing fails

 Fallback Mechanism: Automatic transition to rule-based parsing reduces failed operations

 Storage Efficiency: Structured JSON format provides compact storage of parsed information

 Maintenance Efficiency: Modular architecture simplifies updates and enhancements

User Efficiency

The system significantly improves efficiency for end users in the recruitment process:

 Time Savings: Eliminates manual data entry from resumes (estimated 5 minutes saved per
resume)

 Search Efficiency: Structured data enables rapid candidate identification through filtering

 Information Access: Consistent formatting improves information retrieval speed

 Decision Support: Standardized presentation facilitates faster candidate evaluation

Comparative Efficiency

When compared to existing systems, the LLM-Powered Resume Parser shows efficiency
improvements in several areas:

 Accuracy Improvement: 5-15% higher accuracy compared to traditional rule-based systems

 Adaptability: Superior handling of non-standard formats reduces manual intervention

 Recovery Rate: Higher successful parsing rate reduces the need for manual processing

 Integration Efficiency: Structured output format simplifies integration with other systems

Cost Efficiency
The system demonstrates good cost efficiency in practical deployment:

 Development Cost: Moderate initial investment (approximately $48,500)

 Operational Cost: Reasonable ongoing costs (approximately $36,600 annually)

 ROI: Strong first-year return on investment (312%) with increasing returns in subsequent
years

 Scalability: Linear cost scaling with resume volume through optimized API usage

These efficiency metrics demonstrate that the LLM-Powered Resume Parser provides substantial
operational and economic benefits while delivering superior parsing performance. The system's
hybrid architecture addresses the fundamental efficiency challenges in resume parsing by balancing
accuracy, reliability, and resource utilization.

6.2 Comparison of Existing and Proposed System

The LLM-Powered Resume Parser represents a significant advancement over existing resume parsing
systems, with key differences across multiple dimensions.

Parsing Approach

Existing Systems:

 Rule-Based Systems: Rely solely on predefined patterns and rules, requiring constant
maintenance to keep pace with evolving resume formats

 Machine Learning Systems: Use supervised learning techniques that require extensive
training data and struggle with novel formats

 NER-Based Systems: Focus on entity extraction without comprehensive contextual

understanding

Proposed System:

 Hybrid Architecture: Combines LLM-based semantic understanding with rule-based reliability

 Section-Specific Processing: Applies optimal parsing techniques for different resume sections

 Intelligent Fallback: Gracefully transitions between parsing methods based on success rates

The proposed system's hybrid approach overcomes the fundamental limitations of existing systems
by leveraging the complementary strengths of different parsing techniques.

Accuracy and Performance

Existing Systems:

 Rule-Based Systems: 70-80% accuracy, highly dependent on format standardization

 ML-Based Systems: 80-85% accuracy, requires substantial training data

 NER-Based Systems: 85-90% accuracy for specific entities, weak on contextual relationships

Proposed System:

 Overall Accuracy: 91.3% F1 score across diverse formats

  Education Extraction: 93.8% F1 score

 Experience Extraction: 89.0% F1 score

 Skills Extraction: 91.2% F1 score

The proposed system consistently outperforms existing approaches, particularly for non-standard
resume formats and complex information categories.

Format Handling

Existing Systems:

 Strong performance on standard formats

 Significant degradation with creative or non-standard layouts

 Often requires format standardization before processing

 Limited support for multiple format types

Proposed System:

 Consistent performance across standard and non-standard layouts

 Multi-format support (PDF, DOCX, images) with format-specific processing

 OCR integration for image-based resumes

 Layout-adaptive parsing through semantic understanding

The proposed system's ability to handle diverse formats without significant performance degradation
represents a major advancement over existing solutions.

Error Handling and Reliability

Existing Systems:

 Binary success/failure model for parsing operations

 Complete failure when encountering unexpected structures

 Limited partial information extraction

 Manual intervention required for failed parsing

Proposed System:

 Section-by-section fallback mechanisms

 Graceful degradation with partial information extraction

 94.2% fallback success rate

 Confidence scoring for extracted information

The proposed system's sophisticated error handling dramatically improves reliability in real-world
scenarios with diverse and unpredictable resume formats.

Scalability and Maintenance

Existing Systems:

 Rule-based systems require constant rule updates

 ML-based systems need retraining for new formats or terminology

 Heavy computational requirements for some ML approaches

 Static pattern libraries become outdated

Proposed System:

 Leverages continuously updated LLM knowledge

 Reduced maintenance through semantic understanding

 Efficient resource utilization

 Modular architecture for targeted updates

The proposed system offers improved long-term sustainability with reduced maintenance
requirements, addressing a key challenge in existing parsing solutions.

Integration and Usability

Existing Systems:

 Often provide basic structured outputs

 Limited filtering capabilities

 Frequently require post-processing

 Varying output schemas

Proposed System:

 Comprehensive structured JSON output

 Advanced multi-criteria filtering

 Standardized schema for consistent integration

 Web interface for non-technical users

The proposed system provides superior usability and integration capabilities, making the parsed
information more immediately actionable for recruitment processes.

This comparison demonstrates that the LLM-Powered Resume Parser represents a significant
advancement in resume parsing technology, addressing the core limitations of existing systems while
providing superior accuracy, reliability, and usability.

6.3 Comparative Analysis - Table

The following table provides a detailed comparison between the LLM-Powered Resume Parser and
three representative existing systems:
 Traditional
ML-Based NER-Based LLM-Powered
Feature/Capability Rule-Based
System System Resume Parser
System

Overall Accuracy 75% 83% 87% 91.3%

Skills Extraction
78.3% 84.5% 86.2% 91.2%
Accuracy

Education
Extraction 85.1% 87.3% 89.5% 93.8%
Accuracy

Experience
Extraction 76.4% 82.4% 83.8% 89.0%
Accuracy

Moderate Moderate
Non-Standard Poor (< 60% Good (88.4%
(70-75% (75-80%
Format Handling accuracy) accuracy)
accuracy) accuracy)

Limited Moderate
(requires (requires Good (with Good (inherits
Multilingual
language- language- language from LLM
Support
specific specific models) capabilities)
rules) training)

Moderate Moderate
Fast (3.1 Moderate (7.5
Processing Time (5.8 (6.2
sec/resume) sec/resume)
sec/resume) sec/resume)

Limited Moderate Excellent

Poor (fails
Error Recovery (section- (entity-level (94.2%
completely)
level failure) recovery) recovery rate)

High Moderate
Moderate
Maintenance (constant (entity Low (leverages
(periodic
Requirements rule library LLM updates)
retraining)
updates) updates)

Semantic
None Limited Moderate Strong
Understanding
 Traditional
ML-Based NER-Based LLM-Powered
Feature/Capability Rule-Based
System System Resume Parser
System

Context
None Limited Limited Strong
Comprehension

Requires
Requires
Domain domain- Moderate Good
domain-
Adaptation specific adaptation adaptation
specific rules
training

Implementation
Moderate High High Moderate
Complexity

High
Resource (training),
Low Moderate Moderate
Requirements Moderate
(inference)

Yes (Perplexity
API Dependencies None None None
AI)

Fallback
Limited Limited Limited Comprehensive
Mechanisms

Filtering
Basic Moderate Moderate Advanced
Capabilities

Setup Cost Low High High Moderate

Operational Cost Low Moderate Moderate Moderate

Scalability Good Moderate Moderate Good

This comparative analysis demonstrates the LLM-Powered Resume Parser's advantages across
multiple dimensions. While the system shows slightly longer processing times compared to rule-
based approaches, it delivers significantly improved accuracy and format handling. The hybrid
architecture addresses the limitations of each individual approach, resulting in a more balanced and
capable system overall.

6.4 Comparative Analysis - Graphical Representation and Discussion

The performance of the LLM-Powered Resume Parser compared to existing systems can be visualized
through several key metrics:

Figure 1: Accuracy Comparison by Information Category

Accuracy (%)

95| ┌───┐

| ┌───┐ │ │

90| ┌───┐ │ │ │ │

| ┌───┐ │ │ │ │ │ │

85| │ ││ │ │ ││ │

| ┌───┐ │ │ │ │ │ │ │ │

80| │ ││ ││ │ │ ││ │

| ┌───┐ │ │ │ │ │ │ │ │ │ │

75| ┌───┐ │ │ │ │ │ │ │ │ │ │ │ │

| │ ││ ││ ││ ││ │ │ ││ │

70+──┴───┴─┴───┴─┴───┴─┴───┴─┴───┴──┴───┴─┴───┴──>

RB ML NER LLM RB ML NER LLM

└────Skills────┘ └────Education────┘

RB ML NER LLM RB ML NER LLM

└───Experience───┘ └────Overall────┘

Figure 2: Handling of Non-Standard Resume Formats

Accuracy (%)

90| ┌───┐

| │ │

80| ┌───┐ │ │

| ┌───┐ │ │ │ │

70| ┌───┐ │ │ │ │ │ │

| │ ││ ││ │ │ │

60| ┌───┐ │ │ │ │ │ │ │ │
 | ┌───┐ │ │ │ │ │ │ │ │ │ │

50| │ │ │ │ │ │ │ │ │ │ │ │

| │ ││ ││ ││ ││ │ │ │

40+──┴───┴─┴───┴─┴───┴─┴───┴─┴───┴──┴───┴──>

Rule ML NER LLM Rule ML NER LLM

└──Creative Layouts──┘ └─Multiple Columns─┘

Rule ML NER LLM Rule ML NER LLM

└───Infographics────┘ └─Scanned Documents─┘

Figure 3: Processing Time vs. Accuracy

Accuracy (%)

95| ● LLM-Powered

90| ● NER-Based

85| ● ML-Based

80|

| ● Rule-Based

75|

70+───────────────────────────────────────────────>

0 2 4 6 8 10 12

Processing Time (seconds)

Discussion of Comparative Analysis

The graphical representations highlight several key insights about the LLM-Powered Resume Parser's
performance relative to existing systems:

1. Category-Specific Performance: The LLM-Powered Resume Parser shows the most significant
improvement in skills extraction, where semantic understanding is particularly valuable. The
gap is smaller for education information, where even rule-based systems perform reasonably
well due to the more standardized nature of educational credentials.
 2. Format Handling: The proposed system demonstrates dramatically better performance on
non-standard resume formats, including creative layouts, multiple columns, and infographic-
style resumes. This represents one of the most significant advantages over existing systems,
which typically show sharp performance degradation with non-standard formats.

3. Processing Time vs. Accuracy Tradeoff: While the LLM-Powered Resume Parser has slightly
longer processing times compared to rule-based systems, the accuracy improvement more
than compensates for this difference. The processing time remains well within acceptable
limits for practical recruitment workflows.

4. Balanced Performance Profile: The proposed system shows the most balanced performance
profile across different metrics, without major weaknesses in any particular area. This
contrasts with existing systems that tend to excel in specific dimensions while struggling in
others.

5. Recovery Capabilities: One of the most significant advantages not captured in standard
accuracy metrics is the system's ability to recover from parsing failures. The proposed
system's 94.2% recovery rate means that even challenging documents that cause initial
parsing issues can be successfully processed through fallback mechanisms.

6. Operational Considerations: The comparative analysis reveals that while the LLM-Powered
Resume Parser has moderate implementation complexity and operational costs, it offers
significantly reduced maintenance requirements compared to rule-based systems. This
provides long-term operational advantages that offset the initial implementation effort.

These comparisons demonstrate that the LLM-Powered Resume Parser represents a significant
advancement in resume parsing technology, particularly in addressing the persistent challenges of
format diversity and semantic understanding that have limited the effectiveness of existing systems.
The hybrid architecture successfully combines the strengths of different approaches while mitigating
their individual weaknesses, resulting in a more capable and practical solution for automated resume
information extraction.

7. CONCLUSION AND FUTURE ENHANCEMENTS

7.1 Summary

The LLM-Powered Resume Parser project has successfully developed an innovative approach to
automated resume information extraction by combining the semantic understanding capabilities of
large language models with the reliability of traditional parsing techniques. The system addresses
longstanding challenges in resume parsing, particularly the difficulties in handling diverse formats
and extracting contextually relevant information.

Key Achievements

1. Hybrid Parsing Architecture: The project's primary contribution is the development and
implementation of a hybrid parsing architecture that integrates Perplexity AI's language
model capabilities with rule-based parsing techniques. This approach leverages the
complementary strengths of both methods, resulting in superior overall performance
compared to either approach used in isolation.

2. Multi-Format Support: The system successfully handles various document formats (PDF,
DOCX, images) with format-specific processing techniques, ensuring consistent extraction
 quality regardless of the original document type. This addresses the practical reality of
recruitment workflows where resumes are received in diverse formats.

3. Intelligent Fallback Mechanisms: The implementation of section-specific fallback

mechanisms ensures reliable operation even when primary parsing methods encounter
difficulties. The 94.2% fallback success rate demonstrates the effectiveness of this approach
in maintaining system reliability.

4. Structured Information Extraction: The system extracts comprehensive, structured

information about candidates' skills, education, and experience, organizing this data in a
consistent JSON format that facilitates integration with other recruitment systems and
enables advanced filtering capabilities.

5. Web-Based Interface: The development of an intuitive web interface allows users to upload
resumes, view parsed information, and filter candidates based on multiple criteria, making
the system accessible to non-technical users in recruitment roles.

Performance Summary

The LLM-Powered Resume Parser achieved impressive performance metrics across various
dimensions:

 Overall Accuracy: 91.3% F1 score across diverse resume formats

 Category-Specific Accuracy:

 Skills: 91.2% F1 score

 Education: 93.8% F1 score

 Experience: 89.0% F1 score

 Processing Efficiency:

 Average processing time: 7.5 seconds per resume

 Throughput: Approximately 480 resumes per hour per instance

 Format Adaptability:

 Standard formats: 93.7% accuracy

 Non-standard formats: 88.4% accuracy

 Economic Efficiency:

 First-year ROI: 312%

 Subsequent annual ROI: 856%

Comparative Advantage

When compared to existing resume parsing solutions, the LLM-Powered Resume Parser
demonstrates significant advantages:

 5-15% higher overall accuracy compared to traditional systems

 Superior handling of non-standard resume formats

  Reduced maintenance requirements through semantic understanding

 Enhanced filtering capabilities for more effective candidate matching

 Improved error recovery through intelligent fallback mechanisms

Broader Impact

Beyond its technical achievements, the system has demonstrated potential for significant impact on
recruitment processes:

 Reduction in manual data entry, saving approximately 5 minutes per resume

 Improved candidate matching through structured data and advanced filtering

 Enhanced consistency in candidate evaluation through standardized information extraction

 Reduced bias potential through objective information extraction

 Scalable processing capabilities for high-volume recruitment scenarios

The LLM-Powered Resume Parser project has successfully demonstrated the potential of hybrid AI
approaches in document processing tasks, combining the advanced semantic understanding of large
language models with the reliability and efficiency of traditional techniques. The resulting system
represents a significant advancement in resume parsing technology, addressing key limitations of
existing approaches while providing practical value for recruitment workflows.

7.2 Limitations

Despite its significant achievements, the LLM-Powered Resume Parser has several limitations that
should be acknowledged:

1. LLM Dependency and Variability

 API Dependency: The system relies on external API services for LLM functionality, creating a
potential single point of failure.

 Response Variability: LLM outputs can vary even with identical inputs and carefully
engineered prompts, occasionally leading to inconsistent parsing results.

 Token Limitations: The system is constrained by LLM context window limitations, potentially
limiting performance on extremely lengthy resumes.

 Cost Scaling: API costs scale linearly with usage, potentially affecting affordability for very
high-volume applications.

2. Format and Language Limitations

 Complex Visual Formats: Highly creative resume designs with extensive graphical elements
remain challenging, particularly when visual layout carries semantic meaning.

 Table Handling: Information presented in complex tables is sometimes extracted with

reduced accuracy, especially when tables have nested structures.

 Language Support: While the underlying LLM has multilingual capabilities, the system was
primarily tested and optimized for English-language resumes, with limited validation of other
languages.
  Font and Symbol Recognition: Uncommon fonts or specialized symbols occasionally cause
extraction errors, particularly in OCR processing.

3. Domain-Specific Limitations

 Specialized Terminology: Highly specialized industry terminology or uncommon skill

descriptions may not be accurately recognized, particularly in emerging technical fields.

 Non-Traditional Career Paths: Resumes documenting non-traditional career paths or using

unconventional section organization may be parsed with reduced accuracy.

 Regional Variations: Resume conventions vary significantly by region, and the system has
been primarily tested on North American and European formats.

 Academic CV Format: Lengthy academic CVs with publication lists and grant information
present specific challenges not fully addressed in the current implementation.

4. Technical Implementation Limitations

 Performance Bottlenecks: Image-based resume processing shows significantly longer

processing times due to OCR requirements.

 Scaling Limitations: The current architecture shows performance degradation beyond 15

concurrent users.

 Error Propagation: Errors in section identification can cascade to affect all information within
misidentified sections.

 Limited Feedback Loop: The system lacks automated mechanisms to learn from correction
or validation of its outputs.

5. Practical Deployment Limitations

 Integration Complexity: Integration with existing ATS systems may require custom adapters
due to varying data schemas.

 Security Considerations: Sending resume data to external API services raises potential data
privacy concerns in some jurisdictions.

 Deployment Requirements: The system requires moderately complex infrastructure setup

compared to simpler rule-based alternatives.

 Update Management: Changes to the LLM API or response formats may require prompt
engineering adjustments.

6. Validation Limitations

 Test Corpus Limitations: While diverse, the test corpus of 100 resumes cannot represent the
full spectrum of possible resume formats and contents.

 Ground Truth Subjectivity: Manual labeling of resume information involves some

subjectivity, particularly for skill categorization.

 Real-World Performance: Performance in production environments with unpredictable

resume formats may differ from controlled test results.
  Long-Term Performance: LLM behavior may evolve over time, potentially affecting system
performance without active monitoring.

These limitations represent opportunities for future research and development to further enhance
the capabilities and robustness of the LLM-Powered Resume Parser. While they do not negate the
significant achievements of the current implementation, they should be considered when evaluating
the system for specific deployment scenarios or when planning future enhancements.

7.3 Future Enhancements

Based on the current implementation and identified limitations, several promising directions for
future enhancements to the LLM-Powered Resume Parser are proposed:

1. Advanced LLM Integration

 Model Fine-Tuning: Develop domain-specific fine-tuning for the LLM using labeled resume
data to improve extraction accuracy for specialized fields.

 Prompt Optimization: Implement systematic prompt engineering research to identify

optimal prompting strategies for different resume types and sections.

 Local Model Deployment: Explore deployment of smaller, specialized LLMs locally to reduce
API dependency and address privacy concerns.

 Multi-LLM Architecture: Implement a multi-model approach that selects different LLMs

based on resume characteristics and parsing requirements.

2. Enhanced Document Processing

 Advanced OCR Pipeline: Develop a more sophisticated OCR pipeline with pre-processing
optimizations specifically designed for resume documents.

 Layout Understanding: Incorporate visual layout analysis to better understand the semantic
structure of graphically complex resumes.

 Table Extraction: Implement specialized processing for tabular data in resumes, particularly
for skills matrices and project details.

 Multi-Column Processing: Develop improved techniques for handling multi-column layouts

commonly found in creative resume designs.

3. Multilingual Capabilities

 Language Detection: Add automatic language detection to apply language-specific

processing pipelines.

 Multilingual Prompts: Develop specialized prompts optimized for different languages and
regional resume conventions.

 Cross-Lingual Mapping: Implement standardized skill and qualification mapping across

languages for consistent filtering.

 Region-Specific Processing: Create specialized handling for regional resume formats

(European CV, Asian formats, etc.).

4. Advanced Filtering and Matching

  Semantic Skill Matching: Implement concept-based matching that understands skill
relationships and equivalencies.

 Experience Qualification: Develop algorithms to assess experience quality and relevance,

not just keyword matching.

 Requirement Matching: Add capability to parse job descriptions and automatically match
candidates to position requirements.

 Candidate Ranking: Implement sophisticated ranking algorithms based on multiple criteria

and weighted matching.

5. Learning and Adaptation

 Feedback Integration: Develop mechanisms to incorporate user corrections and feedback to

improve future parsing accuracy.

 Active Learning: Implement active learning approaches to identify challenging cases for
human review.

 Continuous Improvement: Create a pipeline for periodically retraining or updating the

system based on new resume formats and terminology.

 Anomaly Detection: Add capabilities to identify unusual resume elements that may require
special handling or verification.

6. Architecture and Performance

 Distributed Processing: Implement distributed architecture for improved scalability and

performance.

 Asynchronous Processing: Enhance the system with asynchronous processing to improve

concurrency handling.

 Caching Strategies: Develop intelligent caching mechanisms to reduce redundant processing

and API calls.

 Batch Processing: Add optimized batch processing capabilities for high-volume scenarios.

7. Integration and Deployment

 ATS Integration: Develop pre-built connectors for popular ATS platforms to streamline
integration.

 SaaS Offering: Create a fully managed SaaS version with simple API access for third-party
integration.

 Mobile Application: Develop companion mobile applications for on-the-go resume

processing and candidate review.

 Enterprise Features: Add role-based access control, audit logging, and other enterprise-
grade features.

8. Additional Information Extraction

 Certification Extraction: Enhance parsing to better identify and validate professional

certifications.
  Project Portfolio Analysis: Add specialized processing for detailed project descriptions and
portfolios.

 Social and Web Presence: Implement extraction and verification of linked profiles and online
portfolios.

 Accomplishment Quantification: Develop algorithms to identify and highlight quantified

achievements in experience descriptions.

These proposed enhancements represent a roadmap for evolving the LLM-Powered Resume Parser
from its current implementation to an even more capable and comprehensive solution. By
addressing current limitations and expanding functionality in these areas, the system can further
advance the state of the art in resume parsing technology while providing increasing value for
recruitment and HR applications.

8. SUSTAINABLE DEVELOPMENT GOALS (SDGs)

8.1 Alignment with SDGs

The LLM-Powered Resume Parser project aligns with several United Nations Sustainable
Development Goals (SDGs), contributing to broader social and economic objectives beyond its
immediate technical application.

Primary SDG Alignment: SDG 8 - Decent Work and Economic Growth

The project most directly supports SDG 8, which aims to "promote sustained, inclusive and
sustainable economic growth, full and productive employment and decent work for all." By
improving the efficiency, accuracy, and fairness of the recruitment process, the system contributes to
several targets within this goal:

 Target 8.2: Achieve higher levels of economic productivity through diversification,

technological upgrading, and innovation

 The system increases productivity in recruitment processes, allowing organizations

to process more applications with greater accuracy

 Technological innovation in parsing techniques addresses a significant operational

bottleneck

 Target 8.5: Achieve full and productive employment and decent work for all women and men

 More efficient candidate evaluation enables broader consideration of applicants

 Structured data extraction reduces potential for unconscious bias in initial resume
screening

 Improved matching between candidates and positions leads to better employment

outcomes

 Target 8.6: Substantially reduce the proportion of youth not in employment, education or
training

 More effective parsing of entry-level resumes with limited experience helps young
people enter the workforce
  Structured skill extraction helps identify transferable skills from educational
experiences

Secondary SDG Alignments

The project also contributes to several other SDGs in less direct but still meaningful ways:

SDG 4 - Quality Education:

 Supports recognition of educational qualifications across different formats and institutions

 Helps identify skills gaps that can inform educational programs

 Facilitates education-to-employment transitions through better credential recognition

SDG 9 - Industry, Innovation and Infrastructure:

 Demonstrates innovative application of AI technologies to business processes

 Contributes to digital infrastructure for human resources

 Showcases technical innovation through hybrid AI approaches

SDG 10 - Reduced Inequalities:

 Potential to reduce bias in initial resume screening through objective information extraction

 Standardized information presentation may help candidates from non-traditional

backgrounds

 Improved accessibility to recruitment processes for candidates with diverse resume formats

8.2 Relevance of the Project to Specific SDG

The LLM-Powered Resume Parser's alignment with SDG 8 (Decent Work and Economic Growth) is
particularly significant and can be examined through several specific dimensions:

1. Recruitment Efficiency and Economic Impact

Efficient recruitment processes directly contribute to economic growth by:

 Reducing time-to-hire, allowing organizations to maintain productivity

 Lowering recruitment costs, enabling more strategic allocation of resources

 Increasing successful placements through better candidate-position matching

 Enabling organizations to scale hiring during growth phases

The system's demonstrated efficiency improvements (estimated 5 minutes saved per resume, 91.3%
accuracy) represent tangible contributions to these economic objectives.

2. Labor Market Accessibility

The system enhances access to employment opportunities through:

 Processing diverse resume formats, accommodating candidates with different resources and
backgrounds
  Extracting information based on content rather than presentation, potentially reducing
format-based disadvantages

 Enabling broader candidate consideration through efficient filtering, rather than arbitrary
cut-offs

 Standardizing information presentation for more objective evaluation

These capabilities support SDG 8's emphasis on inclusive economic growth and employment access.

3. Skills Recognition and Utilization

Effective skills identification supports labor market efficiency through:

 Accurate extraction of both technical and soft skills across diverse descriptions

 Recognition of equivalent skills described using different terminology

 Structured skill categorization enabling better matching to job requirements

 Identification of transferable skills that may not be explicitly labeled

This aspect of the system contributes to SDG 8's focus on full and productive employment by
ensuring that candidates' capabilities are accurately represented and considered.

4. Technological Innovation in HR Processes

The project exemplifies technological upgrading in HR functions through:

 Application of cutting-edge AI techniques to traditional business processes

 Integration of multiple technological approaches (LLMs, NLP, OCR) in a hybrid architecture

 Demonstration of practical AI applications with measurable business value

 Digital transformation of a traditionally manual process

These innovations align with SDG 8's emphasis on technological upgrading and productivity
enhancement through innovation.

8.3 Potential Social and Environmental Impact

Positive Social Impacts

1. Reduced Bias in Initial Screening:

 Information extraction based on content rather than formatting may reduce

unconscious bias

 Consistent extraction across different resume styles helps standardize evaluation

 Objective information presentation before human review can reduce first-impression

bias

2. Improved Candidate Experience:

 Faster application processing reduces uncertainty for job seekers

  More accurate information extraction ensures candidates are evaluated on their
actual qualifications

 Reduced likelihood of qualified candidates being overlooked due to formatting issues

3. Skills-Based Workforce Development:

 Better identification of skills gaps in candidate pools can inform training programs

 Improved matching between skills and job requirements leads to better role fit

 Recognition of equivalent skills under different names helps candidates transition

between industries

4. Economic Opportunity:

 Reduced hiring costs may enable smaller organizations to compete for talent

 More efficient recruitment processes can accelerate business growth

 Better candidate-position matching may improve job satisfaction and retention

Potential Negative Impacts and Mitigations

1. Algorithmic Bias Risks:

 Risk: LLMs may contain biases that could affect parsing performance across different
demographic groups

 Mitigation: Focus on objective information extraction rather than evaluation,

continuous monitoring for bias, diverse testing corpus

2. Digital Divide Concerns:

 Risk: Candidates without access to modern resume formats or digital tools may be
disadvantaged

 Mitigation: Support for multiple formats including scanned documents, emphasis on

content over presentation

3. Privacy Considerations:

 Risk: Processing personal data through external APIs raises privacy concerns

 Mitigation: Clear data handling policies, potential for local model deployment,
compliance with data protection regulations

Environmental Considerations

1. Resource Efficiency:

 Digital processing reduces paper usage in recruitment workflows

 Efficiency improvements reduce computing resources required for large-scale

recruitment

2. Energy Consumption:

 LLM API usage contributes to data center energy consumption

  Future enhancements could focus on optimizing API calls and exploring more
efficient models

3. Sustainable Business Practices:

 Improved recruitment efficiency contributes to overall business sustainability

 Digital transformation reduces physical resource requirements for HR processes

By considering these social and environmental impacts alongside technical performance, the LLM-
Powered Resume Parser project demonstrates how AI technologies can be developed and deployed
in ways that support broader sustainability objectives while delivering practical business value.

REFERENCES
[1] S. Kopparapu, "Automatic Extraction of Input Data from Resumes to Aid Recruitment Process,"
International Journal of Information Processing, vol. 24, no. 3, pp. 117-132, 2010.
[2] F. Javed and P. Arun, "Rule-based Information Extraction from Resumes," IEEE International
Conference on Data Mining Workshops, pp. 358-365, 2013.
[3] N. Singh, A. Garg, and D. Sharma, "Automated Resume Parsing: Techniques and Challenges,"
International Journal of Information Processing, vol. 18, no. 4, pp. 423-441, 2017.
[4] N. Sayfullina, E. Malmi, Y. Liao, and A. Jung, "Applying Machine Learning to Resume Parsing,"
Journal of Intelligent Information Systems, vol. 42, no. 3, pp. 279-295, 2018.
[5] J. Chen, Z. Zhang, and R. Wang, "Resume Information Extraction with Conditional Random
Fields," IEEE Transactions on Knowledge and Data Engineering, vol. 31, no. 5, pp. 897-910, 2019.
[6] T. Brown, B. Mann, N. Ryder, et al., "Language Models are Few-Shot Learners," Advances in
Neural Information Processing Systems, vol. 33, pp. 1877-1901, 2020.
[7] K. Yu, L. Jiang, and H. Liu, "Deep Learning Approaches for Resume Parsing," Computational
Intelligence, vol. 36, no. 4, pp. 432-451, 2020.
[8] E. Ferrara, A. De Rosa, and D. Rossi, "Transformer-Based Models for Resume Information
Extraction," Neural Computing and Applications, vol. 33, pp. 6187-6201, 2021.
[9] M. Wang, S. Li, and H. Zhang, "Hybrid Resume Parsing: Combining Rules and Deep Learning,"
Knowledge-Based Systems, vol. 235, pp. 107629, 2022.
[10] Y. Zhang and J. Liu, "Document Information Extraction Using Large Language Models,"
Computational Linguistics, vol. 48, no. 3, pp. 567-589, 2022.
[11] A. Vaswani, N. Shazeer, N. Parmar, et al., "Attention Is All You Need," Advances in Neural
Information Processing Systems, vol. 30, pp. 5998-6008, 2017.
[12] J. Devlin, M. Chang, K. Lee, and K. Toutanova, "BERT: Pre-training of Deep Bidirectional
Transformers for Language Understanding," Proceedings of NAACL-HLT, pp. 4171-4186, 2019.
[13] S. Gupta and R. Sharma, "Integrating LLMs with Traditional NLP for Resume Analysis," Expert
Systems with Applications, vol. 213, pp. 118876, 2023.
[14] M. Johnson, T. Wilson, and S. Kumar, "Evaluating Resume Parsing Systems: Metrics and
Benchmarks," Journal of Information Science, vol. 47, no. 5, pp. 612-628, 2021.
[15] H. Martinez and G. Thompson, "Performance Comparison of Commercial Resume Parsing
Solutions," International Journal of Human Resource Management, vol. 34, no. 2, pp. 345-367, 2022.