HRMS migration
Field-level mapping, validation, and rollback between JobScore and Recruit CRM & ATS. We move data and schema; workflows are rebuilt natively in Recruit CRM & ATS.
JobScore
Source
Recruit CRM & ATS
Destination
Compatibility
10 of 11
objects map 1:1 between JobScore and Recruit CRM & ATS.
Complexity
BStandard
Timeline
2-4 weeks
Overview
Moving from JobScore to Recruit CRM is a structural migration that involves collapsing JobScore's five-stage workflow (New, Active with sub-stages, Declined, Withdrawn, Hired) into Recruit CRM's pipeline model, recreating custom application form schemas as custom fields, and resolving JobScore's phone-number deduplication logic before records are written to the destination. JobScore charges per concurrent open job, not per user, which creates billing risk during high-volume hiring; Recruit CRM uses per-seat pricing with an unlimited free trial and charges $85 per user per month. We use Recruit CRM's REST API with batch chunking and exponential backoff to migrate engagement history (interviews, scorecards, notes) and preserve all tag associations on candidate records. Workflows, sequences, email automations, and reporting dashboards do not migrate as code; we deliver a written inventory of every automation and report requiring rebuild in Recruit CRM.
Every standard and custom field arrives verified.
AI proposes the map; you confirm before any record moves.
Parent–child, lookups, and ownership stay linked.
Calls, emails, meetings — with original timestamps.
Documents, uploads, and inline notes move with the record.
Why teams make this switch
Leaving
What's pushing teams away
Choosing
What's pulling them in
Object mapping
Each row shows how a JobScore object lands in Recruit CRM & ATS, including any object-level transformations, lookup resolution, or schema-design dependencies.
Typical mapping — final map is confirmed during the sample migration step.
JobScore
Candidate
Recruit CRM & ATS
Candidate
1:1JobScore Candidate records map directly to Recruit CRM Candidates with name, email, phone, address, and resume preserved. Tags migrate as Recruit CRM labels (multi-select or freeform depending on count). Notes migrate as Candidate notes. Phone-number collision detection runs before any write: for each candidate where a matching phone number already exists in the destination, we present a skip/merge/overwrite choice and document the outcome in the migration manifest. Owner assignment maps to the Recruit CRM recruiter field by email match.
JobScore
Job
Recruit CRM & ATS
Job
1:1JobScore Job records map to Recruit CRM Jobs with title, description, location, department, and employment type preserved. A scoping-stage check verifies all intended jobs are published in JobScore before export; unpublished jobs are flagged for manual supplementation. Status mapping: JobScore published maps to Recruit CRM active/open; archived maps to closed. Department and location fields map to Recruit CRM custom properties or standard fields depending on the account configuration.
JobScore
Application
Recruit CRM & ATS
Candidate-Job Relation (Application)
1:1JobScore Application records (the join between Candidate and Job) map to Recruit CRM applications tied to the candidate and job records. Application date, current stage, and stage-entry timestamps migrate. Custom form field responses map to Recruit CRM custom fields created during schema setup. Custom stage sub-stages from JobScore are collapsed into the nearest Recruit CRM pipeline stage and the most recent sub-stage name is preserved as a custom property for audit continuity.
JobScore
Interview
Recruit CRM & ATS
Interview
1:1JobScore Interview records map to Recruit CRM Interviews with date, time, duration, interview type, and interviewer assignment preserved. The parent Application is resolved at migration time using the Candidate-Job pair, and the interview is attached to the corresponding candidate record in Recruit CRM. Outcome and feedback fields migrate as Interview outcome properties.
JobScore
Scorecard
Recruit CRM & ATS
Evaluation / Scorecard
1:1JobScore Scorecard records (submitted ratings and comments from interviewers) map to Recruit CRM evaluation or scorecard records attached to the parent Interview. Ratings, comment text, and interviewer uid migrate as structured data. Scorecard responses are stored as evaluation records in Recruit CRM linked via the interview reference resolved during the migration.
JobScore
Document (Resume / Attachment)
Recruit CRM & ATS
Candidate Document / Resume
1:1JobScore Documents (resumes, cover letters, attachments linked to Candidates or Applications) are exported as raw file blobs and reattached to the corresponding Candidate record in Recruit CRM. Resume parsing in Recruit CRM processes the raw file on import. File type, original filename, and upload timestamp are preserved as document metadata.
JobScore
Location
Recruit CRM & ATS
Job Location
1:1JobScore Location records (address, city, state, country) map to the location fields on the corresponding Recruit CRM Job. Location is attached at the Job level rather than the Candidate level. If the destination account uses a shared location library, we check for existing locations by address match before creating duplicates.
JobScore
Workflow Stage / Application Status
Recruit CRM & ATS
Pipeline Stage / Disposition
lossyJobScore's five standard stages (New, Active, Declined, Withdrawn, Hired) and any Active sub-stages map to Recruit CRM pipeline stages. We create a pipeline in Recruit CRM that reflects the JobScore stage hierarchy, collapsing sub-stages into the nearest named stage and preserving the sub-stage label as a custom field on the application record. Application Status disposition codes (Declined reasons, Withdrawn reasons) migrate as Recruit CRM custom disposition options.
JobScore
User (Interviewer / Recruiter / Owner)
Recruit CRM & ATS
Team Member / User
1:1JobScore Users who appear as interviewers, recruiters, or owners on any record map to Recruit CRM team members. Resolution is by email match. Any JobScore User without a matching Recruit CRM account is held in a reconciliation queue for the customer's admin to provision before record import resumes. Active and inactive status is preserved.
JobScore
Tag
Recruit CRM & ATS
Tag / Label
1:1JobScore Tags (freeform labels applied to Candidates) migrate as Recruit CRM tags on the candidate record. Unlimited tags are supported on both platforms, so no consolidation is required. Tags are written after candidate records are created so that tag associations can be attached to the correct destination record uid.
JobScore
Email Template
Recruit CRM & ATS
Email Template
1:1JobScore Email Templates (body, subject, trigger conditions) are exported with template name, subject line, and HTML/text body. We confirm Recruit CRM template compatibility (variable syntax support) during scoping and flag any template using JobScore-specific merge field syntax that requires manual adjustment in Recruit CRM. Trigger conditions are documented as a written handoff for the admin to reconfigure in Recruit CRM's workflow or automation layer.
| JobScore | Recruit CRM & ATS | Compatibility | |
|---|---|---|---|
| Candidate | Candidate1:1 | Fully supported | |
| Job | Job1:1 | Fully supported | |
| Application | Candidate-Job Relation (Application)1:1 | Fully supported | |
| Interview | Interview1:1 | Fully supported | |
| Scorecard | Evaluation / Scorecard1:1 | Fully supported | |
| Document (Resume / Attachment) | Candidate Document / Resume1:1 | Fully supported | |
| Location | Job Location1:1 | Fully supported | |
| Workflow Stage / Application Status | Pipeline Stage / Dispositionlossy | Fully supported | |
| User (Interviewer / Recruiter / Owner) | Team Member / User1:1 | Fully supported | |
| Tag | Tag / Label1:1 | Fully supported | |
| Email Template | Email Template1:1 | Fully supported |
Gotchas + challenges
Platform-specific issues from each side, plus the pair-specific challenges that don't show up on either platform's page on its own.
JobScore gotchas
Phone-number deduplication silently overwrites candidate records on import
Only published jobs surface in the API and job feeds
Job-count pricing model creates billing risk during high-volume hiring periods
v2 API rate limits are not publicly documented
Custom workflow stages live only in the Active branch — standard stages are locked
Recruit CRM & ATS gotchas
API rate limits are license-scaled and can throttle bulk migration
Custom field schemas vary per organization and require field-level mapping
Files and email attachments require separate extraction and re-upload
Email sequences and automation logic do not transfer between platforms
Pair-specific challenges
Migration approach
Discovery and scoping
We audit the source JobScore account across all tiers, cataloguing open and closed jobs, candidate count, application volume, interview and scorecard records, tag taxonomy, custom application form schemas, disposition codes, and user roster. We verify job publication status against the admin job list and run phone-number collision detection across the candidate set. The discovery output is a written migration scope with object-level record counts, any flagged unpublished jobs, phone collision summary, and a Recruit CRM configuration checklist.
Recruit CRM schema configuration
We create the target Recruit CRM pipeline structure reflecting the JobScore stage hierarchy, collapsing Active sub-stages into named stages with the original sub-stage label preserved as a custom property. Custom application form fields from JobScore are created as Recruit CRM account-wide custom fields. Disposition codes are configured as options in Recruit CRM. Team members are provisioned or reconciled by email match against the user roster. Schema is validated in Recruit CRM before any data import begins.
Sandbox migration and reconciliation
We run a full migration into a Recruit CRM sandbox environment using production-like data volume. The customer's recruiting operations lead reconciles record counts (candidates in, jobs in, applications in, interviews in, scorecards in), spot-checks 25-50 records against the JobScore source, validates that phone collisions were handled per the agreed policy, and signs off the mapping before production migration begins. Any field mapping corrections and stage collapse adjustments happen in sandbox, not in production.
Candidate and job migration
We migrate Candidates first, resolving owner assignments by email match and handling phone-number collisions per the agreed policy. Tags are written after candidate records exist so associations attach to the correct destination uid. Jobs are migrated next with publication status preserved and location fields mapped. The migration validates parent-record lookups before proceeding to dependent records.
Application, interview, and scorecard migration
Applications are migrated with the Candidate and Job lookups resolved, custom form field values mapped to the new custom fields, and stage history collapsed and preserved. Interviews attach to the correct candidate record using the parent Application uid. Scorecards migrate as evaluations linked to their parent Interview record. Resume and document blobs are reattached to the candidate record with filename and upload timestamp metadata preserved.
Cutover, validation, and automation handoff
We freeze JobScore writes during cutover, run a final delta migration of any records modified during the migration window, then enable Recruit CRM as the system of record. We deliver the email template compatibility report and the workflow and automation inventory document to the customer's admin team. We support a five-day hypercare window where we resolve any reconciliation issues. Workflows and email automations are not rebuilt inside the migration scope; that work is handled by the customer's admin or a separate engagement.
Platform deep dives
JobScore
Source
Strengths
Weaknesses
Recruit CRM & ATS
Destination
Strengths
Weaknesses
Complexity grading
Standard HRMS migration. 1 of 7 objects need a mapping; the rest are 1:1.
Overall complexity
Standard migration
Derived from compatibility, mapping clarity, API constraints, and data volume across JobScore and Recruit CRM & ATS.
Object compatibility
1 of 7 objects need a mapping; the rest are 1:1.
Field mapping clarity
Field mapping is derived from defaults — final spec confirmed during the sample migration.
Timeline complexity
7-object category — typical timelines run 2–7 days end-to-end.
API constraints
JobScore: Not publicly documented in v2 docs; v1 showed 3600 req/hr.
Data volume sensitivity
JobScore doesn't expose a bulk API — REST + parallelization used for high-volume runs.
Estimator
Rule-based pricing — no per-record fees, no manual quotes. Migrations over 2M records are scoped individually.
Step 1
Pick a category, then your source and destination platforms.
Category
FAQ
Answers to the questions buyers ask most during JobScore to Recruit CRM & ATS migration scoping. Not seeing yours? Book a call.
Walk through your JobScore to Recruit CRM & ATS migration with a real engineer — 30 minutes, free, written quote within 24 hours.
Book a free 30 minute consultationAdjacent paths
Other ways to leave JobScore
Other ways to arrive at Recruit CRM & ATS
Ready when you are
Tell us record counts and timeline. We'll come back with a written quote inside 1 business day — no commitment, no sales pitch.