Skip to main content
Resume Parsing & AI Candidate Screening — A build-to-order Frappe app that parses inbound resumes into structured fields, sco — 1/1Illustrative preview

A build-to-order Frappe app that parses inbound resumes into structured fields,

scores each candidate against the ERPNext Job Opening with an AI match engine, and auto-ranks your shortlist — all inside native ERPNext Recruitment.

ECOSIRE scopes, builds, installs, and supports it.

What is Resume Parsing & AI Candidate Screening?

A build-to-order Frappe app that parses inbound resumes into structured fields, scores each candidate against the ERPNext Job Opening with an AI match engine, and auto-ranks your shortlist — all inside native ERPNext Recruitment. ECOSIRE scopes, builds, installs, and supports it. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $999.00 USD; request a quote for a scoped proposal.

Key Features

Frappe doc-event hook (`after_insert`/`before_save` in `hooks.py`) on `Job Applicant` enqueues a background parse job the moment a resume lands
PDF and DOCX text extraction into structured fields — contact info, work history, education, certifications — written to a linked `Resume Profile` DocType
Skill extraction and normalization into a tagged child table, filterable and reportable across every `Job Opening`
AI match-score (0–100) computed against the `Job Opening` description, required skills, and minimum experience, stored on the record
Written scoring rationale persisted per candidate so shortlist decisions are auditable, not a black box
Configurable score threshold that auto-advances candidates through the ERPNext Recruitment interview stages and tags the shortlist
Templated shortlist / rejection / acknowledgement emails fired through Frappe's Email Queue, optionally gated behind a manual approve step
Bias-aware screening: blind configured fields (name, gender, age, nationality, photo) from the scoring prompt, with every automated decision logged for compliance
Whitelisted method (`@frappe.whitelist()`) for on-demand re-parse and re-score from a button on the `Job Applicant` form
Scheduler event (nightly/hourly cron) to batch-score application backlogs and re-rank openings unattended
Frappe REST API endpoints so an external careers site or job board can POST applicants and pull parsed scores
Permissions and role-profile enforcement — recruiters see their reqs, hiring managers see shortlists, raw PII stays gated
List-view and Report Builder columns for match score plus a dashboard chart ranking candidates per opening
Client script on `Job Applicant` surfacing the parsed profile, score, and rationale inline without leaving the form
Idempotent, retry-safe parsing with error logging so a malformed or image-only resume flags for manual review instead of failing silently
Built and tested for Frappe/ERPNext v15 and v16

Built to order, done for you

No DIY setup — a working app, built, installed and supported by ECOSIRE.

  1. 1

    You order

    Start with a one-time build price. We scope it with you at kickoff.

  2. 2

    We build & install

    ECOSIRE builds, configures and installs it on your ERPNext.

  3. 3

    Go live + support

    You go live in about one working week, with two weeks of go-live support. Defects in the code we deliver are fixed free of charge.

Technical Specifications

ERPNext Compatibility
—
License
Licence confirmation required
Python Requirement
Python 3.10+
Database
MariaDB 10.6+

About this Product

High-volume recruiting on ERPNext hits a wall fast. The native Recruitment module gives you Job Applicant, Job Opening, and an interview workflow, but every resume still lands as an opaque PDF or DOCX attachment that a human has to open, read, and manually judge. There is no structured skills data, no match score against the job requirements, and no way to rank fifty applicants without fifty pairs of eyes. When a single opening pulls 200+ applications, recruiters triage on gut feel, strong candidates get buried on page three, and your best people spend their week reading instead of interviewing. ERPNext core simply has no parsing layer and no scoring engine — that road ends where the attachment field begins.

This is a proper Frappe app — its own module, DocTypes, hooks.py doc events, and server scripts — installed onto your ERPNext v15 or v16 bench, not a bolt-on SaaS. When a Job Applicant is created (via the careers webform, an email inbox, or the REST API), a before_save/after_insert doc-event hook enqueues a background job that pulls the attached resume, extracts text from PDF and DOCX, and parses it into structured child-table fields: contact details, work history, education, certifications, and a normalized skills list. We add a Resume Profile DocType linked one-to-one to Job Applicant so the parsed data is queryable, reportable, and permission-controlled like any native record. Skills are extracted and written to a tagged child table so you can filter and report on them across every opening.

The AI match engine reads the linked Job Opening — its description, required skills, and experience thresholds — and computes a 0–100 match score per candidate, with a written rationale stored on the record so the decision is auditable, not a black box. A whitelisted method (@frappe.whitelist()) exposes on-demand rescoring, and a scheduler event can batch-score any backlog on the nightly cron. Results drive an auto-shortlist: candidates above your configurable threshold are advanced and tagged, and (optionally, behind a manual approve step) templated rejection or acknowledgement emails fire through Frappe's Email Queue. Bias-aware controls let you blind configured fields (name, gender, age, photo, nationality) from the scoring prompt and log every automated decision for compliance review. Everything respects ERPNext permissions and role profiles — a recruiter sees their reqs, a hiring manager sees the shortlist, and raw PII stays gated.

Because this is build-to-order, we start from your actual hiring workflow, not a generic demo. After a short scoping call we confirm the DocType design, which resume fields matter to you, your scoring rubric, and your bias-blinding and email policies, then build against a staging bench. You get the installable app source for your version, UAT on staging with a rollback plan, and a git repository handover so you own the code outright. Typical delivery is one working week from confirmed scope. There is no instant download — this is engineered, tested on a copy of your data, and installed by ECOSIRE.

What you get

  • Installable Frappe app source code, built and pinned to your ERPNext version (v15 or v16)
  • Installation and configuration on your bench — app install, scheduler wiring, scoring rubric, threshold and bias-blinding setup
  • Technical documentation: DocType schema, hooks, whitelisted methods, scheduler events, and API endpoints
  • User guide plus a live training session for recruiters and hiring managers
  • UAT on a staging bench against a copy of your data, with a documented rollback plan
  • Post-go-live support window for bug fixes and adjustments after launch
  • Git repository handover so you own and can extend the code outright
  • Configuration workbook capturing your scoring rubric, email templates, and blinded-field policy

Who this is for

High-volume in-house recruiter

Runs 15+ open reqs at once and drowns in 200+ applicants per opening. Needs AI triage that ranks the shortlist inside ERPNext Recruitment so screening takes minutes, not days, without exporting data to another tool.

Talent-acquisition lead / HR manager

Owns hiring throughput and time-to-fill metrics. Wants a defensible, auditable match score with a written rationale per candidate, plus bias-blinding controls and a compliance log to satisfy legal and DEI requirements.

Recruitment agency on ERPNext

Processes candidate pipelines for many clients and needs consistent, fast parsing and scoring at scale, with the Frappe REST API feeding applicants in from external job boards and careers pages.

ERPNext-standardized operations / IT lead

Requires new capabilities to live as a proper Frappe app with clean DocTypes, permissions, and a git handover — no shadow SaaS, no data leaving the ERPNext estate uncontrolled.

How Resume Parsing & AI Candidate Screening Compares

CriterionECOSIRECustom BuildCompetitorERPNext Native
Resume parsingPDF/DOCX parsed into structured DocType fields automatically on applicant creationBuild the parser yourself from scratchBasic keyword extraction, fixed field setResume stored as an opaque attachment only
AI match scoring0–100 score vs Job Opening with written rationale, stored per recordDesign and tune your own scoring modelRarely offered, or a hidden black-box scoreNone — manual judgment
Bias-aware controlsConfigurable field blinding + full compliance decision logBuild and validate the blinding logic yourselfUsually absentNone
ERPNext integrationNative DocTypes, hooks, permissions, role profiles, REST APIDepends entirely on your team's Frappe depthOften a separate SaaS syncing data outNative but no parsing/scoring capability
Fit to your workflowScoped to your rubric, fields, and email policyFully custom but you carry all the effort and riskTake the app's fixed opinions or leave themGeneric recruitment flow only
Code ownershipFull git repository handover — you own itYou own itLicensed, closed, vendor-lockedN/A
Deliveryone working week from confirmed scope, tested on stagingMonths, unpredictable, staffing-dependentInstant install but genericAlready present, but lacks the feature
SupportPost-go-live window + optional retainer, v15/v16 testedSelf-supportedVendor tickets, roadmap not yoursCommunity/ERPNext support only

Frequently Asked Questions about Resume Parsing & AI Candidate Screening

How long does delivery take?

This is build-to-order, not an instant download. Typical delivery is one working week from confirmed scope. After a scoping call we agree the DocType design, scoring rubric, bias policy, and email flows, then build and test on a staging bench before installing on production. Complex integrations or unusual resume formats can extend the timeline, which we flag during scoping.

Does it work with our ERPNext version?

Yes. We build and test for Frappe/ERPNext v15 and v16, and pin the app to your exact bench version so upgrades behave predictably. If you're on an older version we'll discuss a supported path during scoping.

What support and updates do we get after go-live?

Every build includes a post-go-live support window for bug fixes and adjustments. Because you receive the full git repository, your own team can extend the app freely. We also offer ongoing support and enhancement retainers, and version-compatibility updates when you upgrade ERPNext — quoted separately from the initial build.

Where does the AI processing happen and is our candidate data safe?

The app runs on your ERPNext bench and respects Frappe permissions and role profiles throughout. Scoring calls an AI model, and we configure that layer to your policy — including which fields are sent, blinding of PII for bias control, and self-hosted or regional model options where required. Raw resumes and parsed PII stay gated behind ERPNext permissions; nothing is exposed publicly.

How does the bias-aware screening actually work?

You configure which fields are blinded — typically name, gender, age, nationality, and photo — and those are stripped from the prompt sent to the scoring engine so the score reflects skills and experience against the Job Opening, not identity. Every automated advance or rejection is logged with its rationale so you have a defensible audit trail for compliance and DEI review.

Can it read any resume format?

It reliably parses text-based PDF and DOCX resumes into structured fields. Image-only or heavily designed resumes are flagged for manual review rather than failing silently — the parse job is retry-safe and logs errors. We can add OCR for scanned documents as a scoped extension if your inbound volume needs it.

Will it interfere with the native ERPNext Recruitment workflow?

No. It's additive. We link to native `Job Applicant` and `Job Opening` records and drive candidates through the existing interview stages via doc events — your recruiters keep working in standard ERPNext Recruitment, now with a match score, ranked shortlist, and parsed profile surfaced on the form.

Request a quote

Resume Parsing & AI Candidate Screening

A build-to-order Frappe app that parses inbound resumes into structured fields, scores each candidate against the ERPNext Job Opening with an AI match engine, and auto-ranks your shortlist — all inside native ERPNext Recruitment. ECOSIRE scopes, builds, installs, and supports it.

  • Frappe doc-event hook (`after_insert`/`before_save` in `hooks.py`) on `Job Applicant` enqueues a background parse job the moment a resume lands
  • PDF and DOCX text extraction into structured fields — contact info, work history, education, certifications — written to a linked `Resume Profile` DocType
  • Skill extraction and normalization into a tagged child table, filterable and reportable across every `Job Opening`
  • AI match-score (0–100) computed against the `Job Opening` description, required skills, and minimum experience, stored on the record

Request a Quotation

Tell us about your Resume Parsing & AI Candidate Screening requirements and we'll send pricing, licensing options and a tailored proposal — usually within one business day.

No payment now. This sends a quote request to our team — we'll follow up by email with pricing and next steps.