Les détails du produit sont affichés en anglais. Traductions à venir.
Faits en bref
- Prix
- $499.00 USD
- Versions ERPNext
- —
- Temps d'installation
- 30 minutes
- Licence
- Perpétuel unique
- Langues
- 11 langues
Achat unique
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.
$499.00USD
Aucun paiement maintenant. Ceci envoie une demande de devis à notre équipe — nous vous recontacterons par e-mail avec les tarifs et les prochaines étapes.
Fonctionnalités clés
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
À propos de ce produit
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.
Pourquoi choisir Resume Parsing & AI Candidate Screening
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.
Ce que vous obtenez
- 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
Pour qui c'est
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.
Aperçu de l'installation
Télécharger depuis ECOSIRE
Achetez la licence sur ecosire.com et téléchargez le ZIP de l'application Resume Parsing & AI Candidate Screening depuis le tableau de bord de votre compte.
Ajoutez l'application à votre banc
Extrayez le ZIP dans le dossier d'applications de votre banc ou exécutez « bench get-app » avec le chemin d'accès à l'application extraite.
Installer sur votre site
Exécutez `bench --site SITE_NAME install-app APP_NAME` suivi de `bench migrate` pour installer Resume Parsing & AI Candidate Screening et appliquer son schéma.
Activez votre licence
Ouvrez les paramètres de licence ECOSIRE sur votre site et activez votre clé de licence. Nécessite les applications gratuites ecosire_connect et ecosire_license_client.
Comment Resume Parsing & AI Candidate Screening se compare
| Critère | ÉCOSIRE | Construction personnalisée | Concurrent | Odoo natif |
|---|---|---|---|---|
| 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 |
Foire aux questions sur Resume Parsing & AI Candidate Screening
+How long does delivery take?
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.
+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.
Modules associés
Demander un devis
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