A publishable project should frame the problem as evidence-constrained resume tailoring, not as unrestricted resume generation. The research gap is clear: existing systems improve job alignment with keyword extraction, semantic matching, and LLM rewriting, but the evaluation sets are often small and human oversight is still needed. ResumeFlow explicitly proposes alignment and hallucination metrics (Zinjad, 2024), while a recent comparison found that LLMs can match manually tailored resumes in some sections but still produce weaker summaries and motivational statements, supporting a hybrid human–AI design (Olers, 2025).

Recommended methodology

1. Build a master-resume knowledge base. Treat the master resume as the only authoritative source of candidate facts. Convert it into structured records rather than passing only a long document to the LLM. Each record should contain: claim_id, exact evidence text, employer/project, role, dates, technologies, responsibilities, achievements, quantitative value, source location, and confidence. Store separate records for skills, education, certifications, projects, and employment. Label each item as verified, user-approved inference, or not permitted. The model may select, shorten, reorder, and paraphrase verified records, but it must not create a new employer, title, date, tool, qualification, achievement, or number. This is consistent with recent rule-based and NLP systems that aim to improve ATS compatibility while preserving original information (Gupta, 2026).

2. Parse the job description into requirements. Extract each requirement into a structured schema: requirement text, normalized skill, category, importance (required, preferred, or contextual), evidence expected, and location in the posting. Use deterministic extraction first—section parsing, named-entity recognition, skill dictionaries, and normalization—then use an embedding model to identify synonyms. Recent systems combine NER with TF–IDF/cosine similarity (Technology, 2025) and transformer-based semantic matching (Somanna, 2026). Keep exact keyword coverage and semantic equivalence as separate signals; semantic similarity must never be treated as proof that the candidate possesses a skill.

3. Retrieve evidence before generation. For each job requirement, retrieve the top matching master-resume records using hybrid retrieval: exact skill match, BM25 or TF–IDF, and embedding similarity. Re-rank the candidates with a cross-encoder or a transparent weighted rule. A RAG-based resume study used structured parsing, vector storage, BM25/cross-encoder reranking, and measured both content preservation and job alignment (Patra, 2024). The LLM should receive only the selected evidence records and job requirements, not unrestricted instructions to “make the candidate fit.” If no record supports a requirement, output NOT_EVIDENCED and recommend that the user add evidence rather than inventing it.

4. Generate with constrained operations. Generate each bullet from a selected evidence record using permitted operations: paraphrase, compress, reorder, change emphasis, and map an existing skill to the job’s wording when the mapping is justified. Require structured output such as {source_claim_ids, rewritten_text, matched_requirements, unsupported_terms}. Reject any output containing a claim without a source claim_id. Run a second verification pass that checks every entity, date, number, technology, credential, and employment statement against the master record. A defensible architecture is hybrid: deterministic NLP performs scoring, while the LLM has a bounded role and produces explanations from structured inputs; one recent prototype capped the LLM contribution at 20% (Indusekhar, 2026).

5. Add a factuality gate and user approval. Calculate a claim-level support rate:

Support rate = supported generated claims / total factual generated claims × 100.

Also report unsupported-claim rate, contradiction rate, numeric-preservation rate, date-preservation rate, and source coverage. Block export if any high-risk claim is unsupported or contradictory. Display a diff showing the original evidence, generated wording, and source claim IDs. This is more meaningful than a single “hallucination score,” because users can inspect the exact failure. Prior work has identified inflated qualifications and lack of authenticity as major problems in LLM-generated resumes (He, 2024).

Evaluation design for publication

Create a benchmark of master-resume/job-description pairs with expert annotations. Include different occupations, career stages, resume formats, writing styles, and job-description quality levels. Split by candidate, not by sentence, so the same person cannot appear in both training and test data. Compare at least four systems: keyword-only, embedding-only, unrestricted LLM, and your master-resume-constrained hybrid. Use ablations to remove the fact schema, retrieval, verifier, and human approval one at a time.

Report five outcome groups: factuality (unsupported-claim rate, contradiction rate, numeric/date accuracy); content preservation (claim coverage and semantic similarity); job alignment (required-skill precision/recall, weighted requirement coverage, and ranking metrics such as NDCG); document quality (expert ratings for clarity, relevance, readability, and ATS parseability); and efficiency (latency, cost, and editing time). A RAG study reported content-preservation cosine similarity of 89% with RAG versus 72% with an LLM-only condition, but this should be treated as a study-specific result, not a general guarantee (Patra, 2024). Have at least two independent expert raters label factual support and report inter-rater agreement. Use bootstrap confidence intervals or paired tests across complete resumes, not only token-level averages.

Your strongest contribution would be a faithfulness–alignment frontier: show how much job-description alignment increases as the system becomes more aggressive, and where unsupported claims begin to rise. The central hypothesis can be: A master-resume-constrained, retrieval-grounded, claim-verified system reduces unsupported factual claims while retaining useful job alignment compared with unrestricted LLM tailoring. Avoid claiming improved hiring probability unless you run a real downstream study; current prototype evidence includes very small evaluations, such as 15 resume–job pairs (Indusekhar, 2026), so ATS or semantic scores should be presented as proxy measures rather than hiring outcomes.

Use Adzuna as a job-source and retrieval layer, not as the complete recommendation methodology. The stronger design is a staged, hybrid pipeline: parse the uploaded resume into a structured candidate profile, retrieve a broad set of jobs from Adzuna, normalize both sides into the same skill and occupation representation, rank jobs with lexical plus semantic signals, and explain every recommendation with matched and missing evidence. A recent API-based prototype followed the basic pattern of extracting structured resume data and generating context-sensitive job queries, but explicitly identified intelligent ranking as future work (Sanyal, 2025).

Recommended architecture

1. Parse once, preserve the evidence. Convert PDF/DOCX/image input into a master profile containing verified skills, aliases, job titles, employers, dates, education, certifications, location, work authorization if provided, salary preference, remote preference, and experience level. Keep the original text span or page location for every extracted item. Use deterministic parsing and NER first, with OCR only for scanned documents and an LLM fallback for uncertain fields. A recent resume-job system uses multi-format parsing, OCR fallback, normalization, and hybrid lexical/Sentence-BERT matching (Pendela, 2026). Do not let the LLM silently add skills to the profile; send uncertain fields to user confirmation.

2. Normalize skills and occupations. Map variants such as “自然 language processing,” “NLP,” and “text classification” to canonical concepts, but retain the original wording. Keep a distinction between explicit evidence and semantic similarity. A semantic match can suggest that two terms are related; it cannot prove that the candidate has the requirement. Include title normalization, seniority, industry, location, work mode, salary, and recency as separate fields rather than embedding everything into one resume vector.

3. Use Adzuna for candidate generation. Send a compact, structured query derived from the profile: one or more target titles, high-confidence skills, location or remote constraints, experience level, and date filters. Avoid sending the entire parsed JSON blindly. APIs often have their own query semantics, pagination, duplicate postings, missing fields, and inconsistent skill wording. Store the raw response, retrieval timestamp, source job ID, URL, title, employer, location, description, salary fields, and deduplication key. Cache results and periodically refresh them. If an API field is absent, mark it as unknown rather than infer it.

4. Rank with a hybrid model. First apply hard filters for explicit constraints such as location, remote status, authorization, employment type, and minimum salary when the user has supplied them. Then score the remaining jobs using separately reported components:

final_score = 0.30 skill coverage + 0.20 required-skill coverage + 0.15 title/occupation fit + 0.15 semantic similarity + 0.10 experience fit + 0.05 location/work-mode fit + 0.05 freshness

Treat these weights as initial, tunable values—not an industry standard. Use exact or normalized skill matching for required skills, TF–IDF/BM25 for lexical relevance, and a Sentence-BERT-style embedding for semantic similarity. Recent systems report that hybrid keyword, TF–IDF, and transformer signals are more robust and interpretable than relying on one signal alone (Pendela, 2026). A resume-job matching study also used independent embeddings and ranking because this scales more efficiently than classifying every resume–job pair sequentially, and evaluated ranking with NDCG, MAP, and MRR (Bocharova, 2024).

5. Make the result explainable. For every recommended job, show: “matched because,” “missing or unverified,” “hard constraint status,” “estimated experience fit,” and the exact resume evidence supporting each match. Never say “you are qualified” when the system has only found textual similarity. A useful result might say: “Matched: Python, SQL, data analysis. Related wording: ‘forecasting’ ↔ ‘predictive modeling.’ Not evidenced: Tableau. Location constraint: satisfied.” Explainable matching and categorized skill gaps are central features proposed by recent resume-job systems (Chakrawarti, 2025).

6. Add a controlled learning layer later. Start with content-based ranking because a new user has no click history and a new job may have no interaction data. Once you have consented events—impression, click, save, apply, dismiss, and interview—train a learning-to-rank model such as LambdaMART or a neural ranker. Keep offline content ranking as the fallback for cold-start users and newly posted jobs. Research on online job recommendation combines resume information with behavioral signals and hybrid offline/online recommendation to address cold-start and long-tail problems (Gu, 2025). Do not optimize only for clicks: clicks can reward attractive titles rather than genuine fit.

How to evaluate it

Create a test set of resume–job pairs labelled by at least two career or recruitment experts. Evaluate parser precision, recall, and F1 for skills, titles, dates, and employers; retrieval Recall@K; ranking Precision@K, NDCG@K, MAP, and MRR; constraint-violation rate; duplicate rate; latency; and explanation correctness. Compare four baselines: title/keyword search, TF–IDF or BM25, embedding-only ranking, and your hybrid ranker. Later compare against a learned ranker using a time-based split so future postings do not leak into training. A recent contrastive-learning study shows why ranking metrics matter: resume-job matching datasets are sparse, and data augmentation plus contrastive learning improved NDCG over several baselines on two real-world datasets (Yu, 2024).

For your publishable contribution, focus on evidence-grounded hybrid job recommendation from a single uploaded resume. Your research question could be: Does a structured, constraint-aware hybrid ranker improve relevant-job ranking and explanation accuracy over keyword-only and embedding-only baselines while preserving cold-start performance? Adzuna can provide the live candidate jobs, but your research contribution should be the profile schema, normalization, ranking, explanation, and evaluation protocol. Keep resume tailoring as a separate downstream module: first recommend jobs from verified facts; only then generate a tailored resume using the evidence-constrained master-resume method.

Assumptions and design objective

I interpret the project as an open-source, low-latency system that accepts PDF/DOCX/image resumes, converts them into evidence-preserving structured JSON, retrieves live jobs from an API such as Adzuna, ranks the jobs, explains the ranking, and later tailors the resume without inventing facts. The primary research objective should be faithful person–job retrieval, not merely a high similarity score. Recent work supports combining explicit skill matching, lexical retrieval, semantic embeddings, structured resume sections, and explainability rather than relying on a single keyword or embedding signal (Pendela, 2026) (Bocharova, 2024).

1. End-to-end architecture and data flow

A. Ingestion and document understanding

1. Upload the file through a FastAPI service and assign a document ID, user ID, hash, timestamp, language, and parser version.
2. Detect file type and whether the document is text-based or scanned.
3. For text PDFs/DOCX, extract text and coordinates with PyMuPDF and a DOCX parser. For scanned files, route only the affected pages through OCR. Preserve page, bounding-box, and character offsets for every extracted span.
4. Segment the document into summary, experience, projects, skills, education, certifications, languages, and other. A published resume-ranking framework uses OCR/object recognition, section classification, NER, and independent section-level similarity rather than treating the resume as one undifferentiated string (Tanberk, 2023).

Output: DocumentArtifact {document_id, raw_text, pages, blocks, sections, parser_confidence, warnings}.

B. Evidence-preserving profile construction

Convert the document into a canonical candidate profile, for example:

{
  "skills": [{"canonical":"Python", "surface_forms":["Python"], "evidence_ids":["e17"], "confidence":0.98}],
  "experience": [{"title":"Data Analyst", "employer":"...", "start":"...", "end":"...", "claims":["e31"]}],
  "education": [],
  "constraints": {"locations":[], "remote":null, "salary":null, "work_authorization":null},
  "evidence": [{"id":"e17", "text":"...", "page":1, "start":842, "end":848}]
}

Every factual field must point to an evidence span. Store verified, uncertain, and user-confirmed states. An LLM may resolve ambiguous structure, but it must not create a skill, employer, date, qualification, or achievement. Research systems commonly combine deterministic extraction, NER, normalization, and semantic matching; the evidence-preserving schema is the key addition that makes your system auditable (Pendela, 2026) (Nageswarrao, 2026).

C. Job acquisition and normalization

Use Adzuna as one ingestion connector, not as the ranking engine. Generate several compact queries from high-confidence titles and skills rather than sending the complete resume JSON. Store the raw response and normalized job record:

{source, source_job_id, title, employer, description, skills, occupation, location, remote, salary, employment_type, posted_at, url, retrieved_at}.

Deduplicate by source ID first, then by normalized employer/title/location/date and description similarity. Keep retrieved_at and posted_at; live-job results are time-sensitive. Mark absent fields as unknown, never infer them from the title or description.

D. Requirement extraction

Parse each job into requirement objects: requirement_text, canonical skill or occupation, type (required, preferred, contextual), seniority, years, location, and evidence span in the job posting. Use a controlled skill/occupation vocabulary and retain aliases. The system must distinguish an explicit candidate skill from a semantically related phrase: semantic similarity is a retrieval signal, not proof of possession.

E. Candidate generation and ranking

Use a two-stage retrieval design.

Stage 1: high-recall retrieval. Apply hard filters only for user-explicit constraints, then retrieve with BM25 or sparse TF–IDF over title, skills, and description. Run dense retrieval over section-aware embeddings for the resume profile and job records. Precompute job vectors when jobs enter the index. Independent embeddings and ranking scale better than classifying every resume–job pair sequentially (Bocharova, 2024).

Stage 2: interpretable reranking. For the top 100–300 jobs, calculate features:

• required-skill precision and recall;
• preferred-skill coverage;
• title/occupation similarity;
• section-level semantic similarity;
• seniority and experience fit;
• location, remote, salary, and employment-type fit;
• freshness and duplicate penalty;
• data-quality and parser-confidence flags.

Start with a transparent weighted score, then train LambdaMART/XGBoost when labelled relevance or user-interaction data exists. Do not use a black-box LLM as the primary ranker. Hybrid lexical and Sentence-BERT scoring has been proposed as more robust and interpretable than either signal alone (Pendela, 2026). A structured ranking model using NDCG, MAP, and MRR provides a defensible evaluation framework (Bocharova, 2024).

A starting formula is:

score = 0.30 required_skill_coverage + 0.20 skill_precision + 0.15 title_fit + 0.15 semantic_fit + 0.10 experience_fit + 0.05 constraint_fit + 0.05 freshness.

These weights are initial hypotheses, not universal ATS standards. Calibrate them using expert labels and sensitivity analysis.

F. Explanation and downstream tailoring

Return each job with matched evidence, missing or unverified requirements, hard-constraint status, score components, and links to exact resume spans. For example: “Matched: Python and SQL, supported by Experience entry e31. Related wording: forecasting/predictive modelling. Not evidenced: Tableau.” Explainability and categorized skill gaps are recurring design goals in recent systems (Chakrawarti, 2025).

Keep tailoring separate from job retrieval. After the user selects a job, retrieve only the approved master-resume evidence relevant to its requirements and generate a resume variant under claim-level verification. Unsupported claims should produce NOT_EVIDENCED, not generated text. A hybrid resume-ranking design that caps LLM influence and keeps scoring deterministic is a useful pattern for this separation (Indusekhar, 2026).

2. Open-source technical stack

• API and orchestration: FastAPI, Pydantic, Celery or a lightweight task queue, Docker, and PostgreSQL. Use asynchronous jobs for OCR and embedding generation; keep upload requests short.
• Parsing: PyMuPDF for PDF text and coordinates; python-docx for DOCX; Tesseract or PaddleOCR as the scanned-document fallback. Add parser confidence and human correction rather than assuming one parser is universally reliable.
• NLP and extraction: spaCy for sentence processing, NER, phrase matching, and rule-based normalization; regex and date parsers for deterministic fields. A recent system reports spaCy NER F1 of 85.71% versus 79.92% for Flair in its evaluation, although these numbers are dataset-specific (Technology, 2025).
• Embeddings: Sentence-Transformers with all-MiniLM-L6-v2 for a fast baseline; benchmark a stronger E5 or BGE-family encoder if latency permits. One production-oriented study used MiniLM’s 384-dimensional embeddings with cosine similarity on commodity CPU hardware (Mishra, 2026).
• Sparse search: OpenSearch/Elasticsearch BM25, or PostgreSQL full-text search for a smaller deployment. Use FAISS for local dense retrieval and Qdrant or pgvector when persistent filtering and metadata queries are needed.
• Reranking: LightGBM/XGBoost LambdaMART for interpretable feature-based ranking; a cross-encoder only for the small reranking set because pairwise inference is slower.
• Local generation: Ollama or llama.cpp with a small instruction-tuned model for schema repair, explanations, and evidence-constrained tailoring. Generation should be optional; retrieval and scoring must work without it.
• Frontend and observability: React, structured JSON responses, PostHog/OpenTelemetry-compatible event logging, Prometheus metrics, and an audit store for parser versions, model versions, feature values, and explanations.

The stack is not “better” merely because it uses a larger model. The research direction favors structured sections, hybrid retrieval, contrastive or domain adaptation when labels are available, and efficient dual-encoder inference. A recent contrastive-learning study reports gains over BM25 and embedding baselines on ranking metrics, but such results should be independently reproduced on your data (Yu, 2024).

3. Preprocessing, optimization, and evaluation

Preprocessing

Normalize Unicode, whitespace, dates, punctuation, and skill aliases, but retain the original span. Remove contact details from ranking features unless the user explicitly needs location or authorization matching. Detect columns and reading order. Protect negation and context: “familiar with,” “led,” “supported,” and “not used” should not become identical skills. Create synthetic perturbations for column order, synonyms, spelling variation, OCR errors, and paraphrased job descriptions, but never use generated text as ground truth without human review.

Training and optimization

Use a phased strategy:

1. Rule-based baseline: exact canonical-skill matching plus explicit filters.
2. Sparse retrieval: BM25/TF–IDF.
3. Dense retrieval: frozen Sentence-Transformer embeddings.
4. Hybrid reranking: weighted features and LambdaMART.
5. Optional domain adaptation: fine-tune a dual encoder with positive resume–job pairs and hard negatives that share a title but have different requirements. Contrastive learning is appropriate because real interaction data are sparse; ConFit addresses this with section paraphrase augmentation and contrastive training (Yu, 2024).
6. Optional generation: use the LLM only for explanations and evidence-grounded tailoring, evaluated separately from ranking.

Split by candidate and by time. Do not put paraphrases of the same resume in both training and test sets. Use an external job source or occupation domain for out-of-distribution testing.

Metrics

Measure the system at each layer:

• parser: span precision, recall, F1, exact date/title accuracy, OCR character error rate;
• retrieval: Recall@K and candidate-generation coverage;
• ranking: Precision@K, Recall@K, MAP, MRR, NDCG@K, and Spearman/Pearson agreement with expert relevance labels;
• constraints: false acceptance and false rejection for location, salary, remote status, seniority, and authorization;
• explanations: evidence-support precision, unsupported-claim rate, and expert-rated usefulness;
• system: p50/p95 latency, throughput, memory, cost, index freshness, duplicate rate, and failure rate;
• fairness and governance: performance by resume format, language, career stage, employment gap, and demographic groups only where lawful, consented, and appropriately protected.

Do not report only accuracy. A ranking system can have high pairwise accuracy while producing poor top-10 recommendations. A recent framework explicitly notes that ranking, latency, usability, fairness, privacy, and governance all matter in deployment (Raza, 2026).

4. Required baselines and ablations

Compare:

1. title-only API search;
2. exact skill intersection;
3. TF–IDF cosine similarity;
4. BM25;
5. dense embedding cosine similarity;
6. dense retrieval plus cross-encoder reranking;
7. weighted hybrid ranker;
8. LambdaMART/XGBoost ranker;
9. LLM-based pairwise relevance scoring, clearly labelled as a slower and less deterministic baseline;
10. your complete system.

Ablate OCR fallback, section structure, skill normalization, hard constraints, dense retrieval, sparse retrieval, reranking, and explanation verification. Report both quality and latency so the claimed optimization is meaningful.

5. Failure points and mitigations

• Parser failure on columns, tables, icons, and scans: layout-aware extraction, OCR fallback, confidence thresholds, and user correction.
• False semantic matches: separate explicit evidence from related wording; require evidence for “matched skill.”
• LLM hallucination: structured output, evidence IDs, closed retrieval context, claim-level verifier, and export blocking.
• Keyword gaming: cap repeated-keyword contribution and reward requirement coverage rather than frequency.
• API drift, stale jobs, and duplicates: connector versioning, raw-response storage, timestamps, deduplication, and refresh jobs.
• Cold start: content-based ranking first; introduce behavioral learning only after enough consented events. Hybrid online recommenders combine resume information with behavioral signals to address cold-start and long-tail issues (Gu, 2025).
• Popularity and employer bias: evaluate exposure and ranking quality across occupations and groups; use constrained reranking and human override logging. Recent work identifies opacity and fairness as central weaknesses of TF–IDF-based screening (Raza, 2026).
• Data leakage and privacy: encrypt documents, isolate tenant data, minimize retention, hash identifiers, avoid sending resumes to external generation services, and log access.
• Evaluation leakage: candidate/time-based splits, frozen test jobs, external validation, confidence intervals, and expert adjudication of hard cases.

The publishable contribution should therefore be a low-latency, evidence-preserving hybrid recommender: open-source parsing plus OCR fallback, structured master-profile extraction, Adzuna-backed candidate generation, sparse+dense retrieval, transparent reranking, claim-grounded explanations, and rigorous candidate/time-split evaluation. Adzuna supplies live jobs; your research contribution is the faithful representation, ranking, explanation, and validation methodology.

The earlier replies did not include a 26-item bibliography. Below is a consolidated list of relevant records from the project searches, with titles, authors, year, and DOI where available. Some are prototype/system papers; verify publication venue and bibliographic details before using them as scholarly references.

1. “RésuMatcher: A personalized résumé-job matching system” — Shiqiang Guo, Folami Alamudun, and Tracy Hammond (2016). DOI: 10.1016/j.eswa.2016.04.013.
2. “ResumeFlow: An LLM-facilitated Pipeline for Personalized Resume Generation and Refinement” — Saurabh Bhausaheb Zinjad, Amrita Bhattacharjee, Amey Bhilegaonkar, and Huan Liu (2024). DOI: 10.1145/3626772.3657680.
3. “AI-Powered Job Application Management for Applicants” — Author names were not supplied in the indexed record (2025). DOI: 10.5281/zenodo.18106764.
4. “ATSForge: An AI-Powered Career Management Platform for ATS Resume Building, JD Matching, Cover Letter Generation, and Professional Outreach” — Ajay Pratap Yadav, Anshu Prasad, and Deepak Yadav (2026). DOI: 10.55041/ijcope.v2i4.682.
5. “Tailored Resume Generation Using RAG with LLM as per Job Specifications” — Komal Prakashchandra Patra, Manoj Diwakar, and Chandrakala Arya (2024). DOI: 10.1109/PDGC64653.2024.10984036.
6. “Optimizing Resume Authenticity and ATS Compatibility with LLM Feedback Integration” — Katie He and Justin Lau (2024). DOI not listed in the indexed record.
7. “Resume AI: An Explainable Hybrid Agentic Resume Ranking System Using Local LLMs and Deterministic NLP” — Aashutosh Indusekhar, R. Manikandan, T. S. Karthik, V. Nivedita, Targyn A. Nauryz, and S. J. Vimal Aravintha (2026). DOI: 10.69888/ftscs.2026.000688.
8. “ResumeGenAI: Supporting Job Seekers with LLM-Driven Resume Feedback” — Dhruv Awasthi, Pooja S. B. Rao, and Dinesh Babu Jayagopi (2025). DOI: 10.1145/3719160.3737622.
9. “CareerSmart: An Intelligent Recruitment Framework Using TF-IDF, BERT, and Named Entity Recognition for Resume-Job Matching” — Srinivasa Rao Pendela, Arumalla Dharma Tejeswar Reddy, Aremanda Gaurav Vandan, and Sasideepika Dharanikota (2026). DOI: 10.5281/zenodo.19033816.
10. “Intelligent Resume Parsing and Job Recommendation via Web-Based CV Analysis System” — Kaustav Sanyal (2025). DOI: 10.22214/ijraset.2025.70746.
11. “DEEP-MATCH: A Transformer-Based Semantic Resume Screening Framework Using Sentence-BERT and Cosine Similarity” — Anjali Mishra and Amisha Patodi (2026). DOI: 10.33564/ijeast.2026.v11i02.009.
12. “ResJobFit—End-to-End Artificial Neural Networks Based Technology for Job-Resume Matching” — Maiia Y. Bocharova and Eugene V. Malakhov (2024). DOI: 10.15276/aait.07.2024.27.
13. “ConFit: Improving Resume-Job Matching Using Data Augmentation and Contrastive Learning” — Xiao Yu, Jinzhong Zhang, and Zhou Yu (2024). DOI: 10.1145/3640457.3688108.
14. “Together Is Better: Knowledge-Aware Model with Resume Fusion for Online Job Recommendation” — Xiao Gu, Ling Jian, C. R. Rao, Zhaohui Bu, and Xianggang Cheng (2025). DOI: 10.1145/3716503.
15. “Resume Based Job Recommendation for Job Seekers” — Aby Jose and Meera Rose Mathew (2023). DOI: 10.5281/zenodo.7960845.
16. “ResuMatch: AI-Powered Resume-Job Description Matching System” — Vishwas Chakrawarti, S. K. Pathak, Vishal Gupta, Aman Kumar, and Mohd. Sadim (2025). DOI: 10.55041/ijsrem55160.
17. “Job Tailored Resume Content Generation” — Sumedh S. Kale and William Andreopoulos (2023). DOI: 10.1109/BigDataService58306.2023.00012.
18. “ApplicantAI: Transforming Resume Creation, Leveraging LLMs for Job Applications” — Dustin Yan, Melody Moh, and Teng-Sheng Moh (2025). DOI: 10.1109/BigData66926.2025.11401836.
19. “IntelliResume: A Context-Aware Framework for Resume Optimization Using Transformer-Based Semantic Matching” — N. Somanna, Chekka Vijaya Lakshmi, M. Santhoshi, Kuvura Siri, Kuruva Mamatha, and Bavigadda Vani (2026). DOI: 10.1109/ICADCS70036.2026.11583307.
20. “AI-Enabled Resume Builder with Automated Job Recommendation System” — Poornima, Bharath U, Gayathri P, Devi K, and Ezaz Ahmed Shaik (2026). DOI: 10.5281/zenodo.20622302.
21. “HireLoop: A Custom Machine Learning Based Resume Tailoring and ATS Optimization Platform” — Devasya Gupta (2026). DOI: 10.5281/zenodo.19336066.
22. “GenAI CV: A GDPR-Compliant, AI-Driven Resume Builder for ATS Optimisation” — M. A. Hannan Bin Azhar (2025). DOI: 10.1109/ICICyTA68677.2025.11362795.
23. “Resume Matching Framework via Ranking and Sorting Using NLP and Deep Learning” — Senem Tanberk, Selahattin Serdar Helli, Ege Kesim, and Sena Nur Cavsak (2023). DOI: 10.1109/UBMK59864.2023.10286605.
24. “Combination of Neural Networks and Conditional Random Fields for Efficient Resume Parsing” — C. H. Ayishathahira, C. Sreejith, and C. Raseek (2018). DOI: 10.1109/CETIC4.2018.8530883.
25. “Retrieval-Augmented Generation for Resume Screening Using Sentence Transformers” — Bhavesh Kumar P. and Ganesh Kumar Chellamani (2025). DOI: 10.1109/ICCCA66364.2025.11325309.
26. “AI-Resume Builder and Job Optimization Website” — Dhinakaran D, Poli Vishnu Vardhan Reddy, and Jaladi Vishnu Vardhan (2026). DOI: 10.1109/ICIETSD68684.2026.11584874.

Note: These are 26 relevant records from the saved project searches, not 26 papers all cited individually in the earlier prose responses.