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 $499.00 USD; request a quote for a scoped proposal.

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.
ابھی کوئی ادائیگی نہیں۔ یہ ہماری ٹیم کو قیمت کی درخواست بھیجتا ہے — ہم قیمت اور اگلے اقدامات کے ساتھ ای میل کے ذریعے رابطہ کریں گے۔
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.
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
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 2–4 weeks from confirmed scope. There is no instant download — this is engineered, tested on a copy of your data, and installed by ECOSIRE.
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.
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.
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.
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.
Buy the license on ecosire.com and download the Resume Parsing & AI Candidate Screening app ZIP from your account dashboard.
Extract the ZIP into your bench's apps folder, or run `bench get-app` with the path to the extracted app.
Run `bench --site SITE_NAME install-app APP_NAME` followed by `bench migrate` to install Resume Parsing & AI Candidate Screening and apply its schema.
Open the ECOSIRE License settings on your site and activate your license key. Requires the free ecosire_connect and ecosire_license_client apps.
| Criterion | ECOSIRE | Custom Build | Competitor | Odoo Native |
|---|---|---|---|---|
| Resume parsing | PDF/DOCX parsed into structured DocType fields automatically on applicant creation | Build the parser yourself from scratch | Basic keyword extraction, fixed field set | |
| AI match scoring | 0–100 score vs Job Opening with written rationale, stored per record | Design and tune your own scoring model | Rarely offered, or a hidden black-box score | |
| Bias-aware controls | Configurable field blinding + full compliance decision log | Build and validate the blinding logic yourself | Usually absent | |
| ERPNext integration | Native DocTypes, hooks, permissions, role profiles, REST API | Depends entirely on your team's Frappe depth | Often a separate SaaS syncing data out | |
| Fit to your workflow | Scoped to your rubric, fields, and email policy | Fully custom but you carry all the effort and risk | Take the app's fixed opinions or leave them | |
| Code ownership | Full git repository handover — you own it | You own it | Licensed, closed, vendor-locked | |
| Delivery | 2–4 weeks from confirmed scope, tested on staging | Months, unpredictable, staffing-dependent | Instant install but generic | |
| Support | Post-go-live window + optional retainer, v15/v16 tested | Self-supported | Vendor tickets, roadmap not yours |
This is build-to-order, not an instant download. Typical delivery is 2–4 weeks 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.
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.
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.
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.
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.
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.
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.
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.