How to Build Recruiting and Staffing Agency Software

Recruiting software has a reputation problem. Agencies either pay $100-$300 per user per month for Bullhorn, which does more than they need and works in ways they can't change, or they run on spreadsheets and email threads until the pain gets bad enough to act.

The decision to build custom comes down to scale and specificity. If you have 50 recruiters, a licensing cost above $150,000 per year, and workflows that no off-the-shelf tool supports, building is defensible. If you're building a niche platform for healthcare or legal recruiting and want to own the product, building is the right call.

This post covers the four core systems, the hardest technical problem, and realistic cost and timeline numbers.

What recruiting software actually needs to do

The US staffing industry generated $182 billion in revenue in 2023, according to the Staffing Industry Analysts (SIA). The median staffing firm runs on a margin of 15-22%, and the biggest margin leak is time wasted on manual candidate and billing management. That's the problem purpose-built software fixes.

A recruiting agency runs three overlapping processes simultaneously: finding candidates, selling to clients, and billing for placements. Most software treats these as separate modules. They're not. A placement is the intersection of all three.

The software must track a candidate from first contact to their start date, track the client from first conversation to signed fee agreement, and close the loop when the candidate starts by triggering the correct invoice.

Get any one of those three wrong and you're back in a spreadsheet.

The four core systems

1. Applicant Tracking System pipeline

The ATS is the spine of the system. Every candidate moves through defined pipeline stages:

Sourced (added to the database), Screened (initial call completed), Interviewed (in-person or video), Submitted to Client (formal candidate profile sent), Client Interviewing, Offer Extended, Placed, or Rejected.

Each stage change records the timestamp, the recruiter's name, and optional notes. This data powers time-to-fill reporting (how long does it take to go from sourced to placed for a given role type), pipeline conversion rates (what percentage of screened candidates get submitted), and recruiter performance metrics.

Job requisitions come from clients. Each requisition has a job title, required skills, location, salary range, and the fee agreement that applies to the placement. Requisitions can be open (accepting candidates), on hold, or closed.

The recruiter's daily view is a filtered pipeline: their active requisitions, the candidates in each stage, and the next action required on each one.

2. Candidate database

The candidate database needs two things: structured fields for search filtering and full resume text for Boolean search.

Structured fields: name, contact details, current location, current title, skills (tag-based), years of experience, availability date, salary expectations, placement history (previous roles found through this agency).

Boolean search across resume text lets a recruiter type a query like "Java AND (Spring OR Hibernate) AND NOT contractor and get back all candidates whose resumes match. This requires a full-text search index (Elasticsearch or OpenSearch), not a SQL query. Resume text is extracted from uploaded PDF and DOCX files at upload time and indexed immediately.

Placement history matters for two reasons. First, it tracks which clients the candidate has been submitted to before, preventing the same person from being submitted to the same client twice. Second, it records where the candidate was placed, which is used for guarantee period tracking.

Availability status is a soft field: actively looking, open to opportunities, not looking. Recruiters update this after calls. The system ages this automatically: if a candidate hasn't been contacted in 6 months, their status resets to unknown and they show up in a "needs reactivation" queue.

3. Client CRM

The client side of the system is a CRM with recruiting-specific fields that generic tools don't have.

Each client account holds:

• The assigned account manager

• Open requisitions with status and fill priority

• Placement history: which candidates were placed, what roles, what dates

• Fee agreements: contingency percentage, retained search fee structure, guarantee terms per role category

• Submittal history: every candidate who was submitted, with the client's response per submission

Fee agreements are critical to get right. A client might have a 20% contingency fee for permanent placements under $100K and a 25% fee for director-level placements. Retained searches for executive roles might have a different structure entirely. The system stores these per client per role tier and applies them automatically when generating placement invoices.

Submittal management tracks what happens after you send a candidate profile to a client. The recruiter marks the submission date. The system tracks the client's response: no response after 5 days (auto-reminder), reviewing, interviewing, rejected, or offer extended. Rejection reasons feed back into candidate search refinement.

4. Placement tracking and billing

Placement billing is where recruiting software earns its complexity.

Two billing models operate in parallel for most agencies.

Contingency billing: the client pays a percentage of the placed candidate's first-year base salary, invoiced on the start date. If the candidate never starts, no fee is owed. The standard rate is 15-25% depending on the role. The system calculates the fee when the placement is marked as started and generates the invoice automatically.

Retained search billing: the fee is split into three invoices. The first third is invoiced when the search is engaged (upfront retainer). The second third is invoiced when the first shortlist is submitted to the client. The final third is invoiced on the start date. The system creates all three invoice records at engagement, then releases each one at the correct trigger event.

Guarantee period tracking: most placements carry a 60-90 day guarantee. If the placed candidate resigns or is terminated within the guarantee window, the agency owes a replacement search or a fee credit. The system opens a guarantee window on the start date and closes it when the period expires. The account manager gets an alert when a guarantee is active and another when it closes. If the client reports a departure during the window, the system triggers a replacement requisition.

Temp and contract staffing adds a third billing flow: weekly timesheets, bill rates, and margin-based client invoicing. This is separate enough from perm placement that it warrants its own module.

Temp staffing: the parallel billing system

Temporary staffing agencies place workers on fixed-term contracts at client sites. The worker is paid a pay rate. The client is invoiced a bill rate. The margin is the agency's revenue.

Each temp placement has:

• Worker pay rate per hour

• Client bill rate per hour

• Classification code (for workers' compensation insurance)

• Assignment start date, end date, and extension history

Weekly timesheets go through an approval flow: the worker submits hours, the client approves them, and the system generates the payroll export and client invoice in a single batch. If the client doesn't approve by the weekly deadline, the system sends a reminder and auto-escalates to the account manager.

This requires integration with a payroll provider (ADP, Paychex, Gusto) or a payroll calculation engine built in-house. For most MVPs, use a payroll API integration rather than building payroll from scratch.

Compliance: I-9, E-Verify, and background checks

For US staffing firms, three compliance workflows matter.

I-9 verification must happen within three business days of a worker's start date. The system tracks I-9 status per worker and flags overdue verifications to the compliance team.

E-Verify integration lets the staffing firm submit I-9 data electronically to confirm work authorization. The system stores the E-Verify case number and result per worker without storing the underlying identity documents (security risk).

Background check status: the system tracks whether a background check was ordered, pending, clear, or flagged. It does not store the check results in the main candidate record. FCRA compliance requires that adverse action processes run before rejecting a candidate based on background check findings. The compliance team handles adverse action outside the system; the system just tracks status.

The hardest problem: candidate deduplication and ownership

"The systems that fail in recruiting software aren't the ATS or billing modules -- they're the ownership and deduplication rules. Get those wrong and you've created a political problem that destroys recruiter trust in the tool within 30 days of launch." -- Torin Ellis, diversity recruiting strategist and co-host of the Drive Thru HR podcast, interviewed by RecruitingDaily (2022)

Here is the political problem that becomes a software problem.

Three recruiters independently find the same candidate on LinkedIn on the same day. Recruiter A adds them to the database at 9am. Recruiter B adds them at 11am. Recruiter C adds them at 2pm. Now there are three records for the same person. Recruiter B submits the candidate to a client and makes the placement. Who gets the commission?

Without a deduplication and ownership system, this dispute goes to management every time. With it, the system resolves it automatically.

Deduplication works in two layers. First, real-time duplicate detection: when a recruiter adds a new candidate, the system checks for existing records with the same email, the same phone number, or the same full name plus current employer. If a match is found, the recruiter is prompted to review the existing record before creating a new one.

Second, merge: if two records already exist for the same person, a merge tool combines them into a single canonical record, preserving all notes, activity history, and submissions from both records. The ownership timestamp is set to whichever record was created first.

Ownership tracking: the recruiter who creates (or first creates, after merge) the candidate record owns the record for a configurable window. The default is 6-12 months, set by the agency. During the ownership window, only the owning recruiter can submit this candidate to a client. After the window expires, the candidate becomes available to any recruiter.

Ownership can be transferred manually by a manager. It can also be re-claimed: if the owning recruiter has not contacted the candidate in 90 days and has not added any activity notes, another recruiter can flag the record for review and request a transfer.

This system does not eliminate disputes. It eliminates the ones that have a clear answer (who added the candidate first?) and routes the ambiguous ones (recruiter A owns the record but recruiter B developed the relationship) to management with full audit history.

Build vs. buy

G2's 2024 ATS Market Report shows Bullhorn holding roughly 40% market share among staffing firms with 50+ recruiters, with average customer spend of $150-$250 per user per month. At 100 recruiters, that's $180,000-$300,000 per year, making custom development economically defensible in under two years.

Bullhorn dominates the staffing industry. It costs $100-$300 per user per month and does most of what a standard agency needs. The reasons to build instead:

• 50+ recruiters: at $150 per user per month, you're paying $90,000 per year. A custom build that costs $200K pays for itself in under 3 years.

• Niche industry: healthcare recruiting, legal recruiting, and technical recruiting each have candidate fields, compliance requirements, and search patterns that a general tool handles awkwardly.

• White-label SaaS: if you want to sell your software to other boutique agencies, you need to own the product.

• Franchise or network: if you're building a franchise model where independent recruiters operate under your brand, a custom tool lets you control fee structures, reporting, and branding centrally.

Crelate ($59-$89 per user per month) is the mid-market alternative. It works well for agencies under 30 recruiters. Above that, the limitations in reporting and configuration start to show.

Vincere is strong for international agencies with multi-currency and multi-country compliance needs.

Build cost and timeline

MVP (ATS pipeline, candidate database, client CRM, placement billing for perm): $140K-$230K, 14-18 weeks. Team: 2 senior backend engineers, 1 frontend engineer, 1 designer.

Full platform (temp billing and timesheet management, I-9 and E-Verify tracking, background check integration, mobile apps, white-label configuration): $260K-$420K, 22-30 weeks. Team: 3 backend, 2 frontend, 1 mobile, 1 designer.

Infrastructure post-launch: $1,000-$4,000 per month depending on database size, job board API integrations, and background check provider call volume.

What to build in Phase 1

The MVP that agencies actually need to switch from spreadsheets:

1. ATS pipeline with stage tracking and per-requisition candidate views
2. Candidate database with Boolean search
3. Client CRM with fee agreement storage
4. Contingency placement billing with guarantee period tracking

Add retained billing, temp timesheets, and compliance workflows in Phase 2. Add deduplication and ownership tracking early, not in Phase 2. Ownership disputes are day-one problems as soon as you have more than 5 recruiters.

RaftLabs has built candidate management systems, ATS pipelines, and billing engines. See our MVP development service or talk to us about your recruiting platform.