Private Recruiting Network
Operational Business Model – 1 Page Summary
1. Job Intake – How Jobs Enter the System
Jobs can enter from:
- JR’s spreadsheet (primary source)
- MyNiceJob via JobPipe
- Manual entry
- Future integrations (Reflik, API, etc.)
When uploaded, each job automatically goes into:
Default State: Unassigned Queue
Note: important.
Jobs do NOT immediately go public.
They enter a controlled queue where leadership decides what happens next.
2. Assignment Logic – Internal First
From the queue, the job can be:
Option A — Auto Assign
System can assign to:
- Recruiter with lowest active workload
- Recruiter with matching specialty
- Specific recruiter chosen manually
Option B — Manual Assign
Admin selects recruiter.
Option C — Leave Unassigned
Wait for strategy decision.
This creates operational flexibility.
3. Primary Window Protection
If assigned to a recruiter:
The job enters a Primary Window (e.g., 3–5 days).
During this time:
- Only the assigned recruiter (or assigned company) can submit.
- No outside agency sees it.
- No network competition.
This preserves relationship control and internal trust.
4. Opening to Network (Controlled Expansion)
After the primary window:
Job can be switched to:
- Selected agencies only
- All network agencies
- Independent recruiters (if allowed)
- Remain internal
This is a manual or automated switch.
This is where scale happens — but only when leadership decides.
5. Protection Model
Even when opened:
- Candidate ownership is permanent.
- Duplicate submissions are blocked.
- Split logic is automatic.
- Audit trail logs all actions.
- Job owner retains client control.
Sharing does NOT mean losing control.
6. Candidate Flow
Candidates can:
- Be submitted by recruiters.
- Apply directly (if open).
- Be reused across multiple jobs.
- Enter lifecycle lock after placement.
- Reactivate automatically.
This creates repeat revenue cycles.
7. Revenue Flow
On placement:
Example:
$40,000 fee
- $4,000 → Network (10%)
- $36,000 → Recruiter(s)
If split:
- $18,000 each
If solo:
- $36,000 single recruiter
Network earns from activity, not membership.
More collaboration = more revenue for everyone.
8. Why This Works Operationally
This system:
- Reduces manual tracking
- Eliminates duplicate submissions
- Automates split disputes
- Increases internal sourcing
- Shortens time-to-fill
- Preserves ownership
- Encourages collaboration without chaos
9. What Changes
Still continue to:
- Owns client relationships
- Negotiates fees
- Assigns recruiters
- Decides when to open jobs
- Controls strategy
What changes:
- Less admin friction
- No split arguments
- No spreadsheet chaos
- Automatic lifecycle tracking
- Increased network velocity
He moves from operator to network orchestrator.
10. Why This Is Stronger Than Current Model
Current model:
- Manual control
- Limited scaling
- Spreadsheet dependency
- Relationship-based enforcement
New model:
- Rule-based enforcement
- Structured expansion
- Automated protection
- Scalable collaboration
- Recurring revenue cycles
This is not replacing the business.
It is installing infrastructure underneath it.
This shows:
Job Intake → Queue → Assignment → Primary Window → Network Open → Placement
Simple but complete.
JOB FLOW DIAGRAM
Queue → Assignment → Network Expansion Model
┌─────────────────────────┐
│ JOB ENTERS SYSTEM │
│ (Spreadsheet / Manual) │
└─────────────┬───────────┘
│
▼
┌─────────────────────────┐
│ DEFAULT STATE │
│ UNASSIGNED QUEUE │
└─────────────┬───────────┘
│
┌────────────────┼────────────────┐
│ │ │
▼ ▼ ▼
┌────────────────┐ ┌────────────────┐ ┌────────────────┐
│ Auto Assign │ │ Manual Assign │ │ Hold in Queue │
│ (Low workload) │ │ (Admin picks) │ │ (Strategy wait)│
└─────────┬──────┘ └─────────┬──────┘ └─────────┬──────┘
│ │ │
└──────────────┬─────┴──────────────┬────┘
▼
┌─────────────────────────┐
│ PRIMARY WINDOW ACTIVE │
│ (Exclusive period) │
│ Only assigned recruiter │
│ can submit candidates │
└─────────────┬───────────┘
│
Primary Window Ends (or manual override)
│
▼
┌──────────────────────────────┐
│ DECISION: OPEN TO NETWORK? │
└─────────────┬────────────────┘
│
┌──────────────────┼─────────────────────┐
│ │ │
▼ ▼ ▼
┌────────────────┐ ┌──────────────────┐ ┌──────────────────┐
│ Keep Internal │ │ Open to Selected │ │ Open to All │
│ Only │ │ Agencies │ │ Network Agencies │
└─────────┬──────┘ └─────────┬────────┘ └─────────┬────────┘
│ │ │
▼ ▼ ▼
Submissions Submissions Submissions
(internal only) (controlled) (competitive)
What Happens After Open-to-Network
Once open:
- Agencies can submit candidates
- Duplicate submissions blocked
- Candidate ownership preserved
- Split logic auto-calculated
- All actions logged
Then:
Candidate Submitted
│
▼
Interview Process
│
▼
Offer Accepted
│
▼
Placement Created
│
▼
Candidate Locked
│
▼
15-Day Pre-Market
│
▼
Reactivated to Network
Why This Flow Is Powerful
It ensures:
- Control first.
- Fair exclusive opportunity.
- Structured expansion.
- No chaos.
- No surprise competition.
- Automated splits.
- Lifecycle reuse.
It is:
Controlled growth, not uncontrolled sharing.
Business Meaning in Simple Terms
Jobs do not immediately go public.
They move through controlled stages:
Queue → Internal Priority → Strategic Expansion → Full Liquidity
That is the difference between:
A job board (immediate public chaos)
and
A structured recruiting exchange.
three clean diagram sections you can paste into a doc or slide deck.
Candidate Ownership & Split Flow
Revenue Movement Diagram
1-Slide Executive Overview
All written clearly, business-first.
1. Candidate Ownership & Split Flow Diagram
Candidate Ownership Protection Model
Candidate Created
│
▼
┌─────────────────────────┐
│ Permanent Owner Set │
│ (Agency A) │
└─────────────┬───────────┘
│
▼
Candidate Status = AVAILABLE
│
▼
┌─────────────────────────┐
│ Candidate Submitted to │
│ Job (Owned by Agency B) │
└─────────────┬───────────┘
│
▼
┌──────────────────────────────────┐
│ Is Agency B Primary on Job? │
└─────────────┬────────────────────┘
│
┌──────────┴──────────┐
▼ ▼
No (Open Job) Yes (Primary Window)
Single Recruiter Split Logic Triggered
Keeps Full Share If Placed → 50/50
What This Means
- Candidate ownership NEVER transfers.
- Candidate owner always remains linked.
- If another agency closes the deal:
- Split is automatic.
- No argument.
- No politics.
- Candidate owner can see process updates.
- Candidate cannot be double-submitted to same job.
This removes trust friction.
2. Revenue Movement Diagram
Revenue Flow on Placement
Example: $40,000 placement fee
Client Pays $40,000
│
▼
┌─────────────────────┐
│ Network Fee 10% │
│ = $4,000 │
└──────────┬──────────┘
│
▼
Remaining = $36,000 Recruiter Pool
│
▼
┌─────────────────────────────┐
│ Was Split Triggered? │
└──────────┬──────────────────┘
│
┌──────────┴──────────┐
▼ ▼
No Split Split Case
$36,000 to $18,000 each
One Agency (Owner + Primary)
Why This Is Important
- Network always earns 10%.
- Recruiters earn more when they collaborate.
- Split logic is enforced automatically.
- No spreadsheet reconciliation needed.
- Revenue math is transparent and logged.
This aligns incentives.
3. Executive-Level One-Slide Diagram
Private Recruiting Network Model
JOB ENTERS SYSTEM
│
▼
Unassigned Queue
│
▼
Assigned Internally
│
▼
Primary Window
│
▼
Open to Network (Optional)
│
▼
Controlled Submissions
│
▼
Placement
│
▼
10% Network Fee + Split Logic
│
▼
Candidate Lifecycle Lock
│
▼
Reactivation to Network
What Makes This Different
Traditional Model:
- Manual tracking
- Spreadsheet splits
- Ownership confusion
- Limited scaling
- One-off placements
Network Model:
- Ownership enforced
- Automatic split logic
- Controlled sharing
- Audit trail
- Lifecycle reuse
- Recurring revenue
The Big Picture
This system:
• Preserves control
• Protects ownership
• Encourages collaboration
• Automates revenue alignment
• Reduces friction
• Increases placement velocity
• Creates recurring candidate reuse
It is structured expansion, not uncontrolled sharing.
Perfect. This is exactly how we should do this — start with a real input source and force the schema to prove it can handle it.
You’re correct:
Build around his spreadsheet first
Then
Your output stopped at “Build around his spreadsheet first Then”. Can you continue from there
Perfect — continuing cleanly.
Build around his spreadsheet first
Then expand the engine to handle external feeds like Reflik later
This is exactly the right order.
His spreadsheet is:
- Structured
- Clean
- Controlled
- Relationship-based
- High quality jobs
- Already generating revenue
That makes it the perfect Phase 1 ingestion model.
Step 1 — Complete Dump of Core Network Tables (Current Design)
Below is the full logical table structure (simplified view, all relevant fields shown).
net_companies
| Field | Purpose |
|---|---|
| id | Internal PK |
| name | Company Name |
| slug | URL handle |
| status | pending / active / probation / etc |
| invited_flag | 1/0 |
| onboarding_fee_status | required / waived / paid |
| created_at | |
| updated_at |
net_users
| Field | Purpose |
|---|---|
| id | PK |
| wp_user_id | Link to WP |
| company_id | FK to net_companies |
| role | platform_admin / network_admin / agency_admin / recruiter / candidate |
| status | active / inactive |
| created_at | |
| updated_at |
net_jobs
| Field | Purpose |
|---|---|
| id | PK |
| job_owner_company_id | Who owns client |
| created_by_user_id | Who created |
| title | Job title |
| description | Full description |
| location | City |
| work_type | onsite / remote |
| placement_fee | Expected fee |
| visibility_mode | assignment logic |
| assignment_mode | exclusive / open |
| primary_company_id | Primary recruiter |
| status | open / closed |
| exclusive_until | For hybrid logic |
| opened_to_network_at | Timestamp |
| created_at | |
| updated_at |
net_job_visibility
| Field | Purpose |
|---|---|
| job_id | FK |
| company_id | FK |
| can_view | 1/0 |
| can_submit | 1/0 |
| is_primary | 1/0 |
net_candidates
| Field | Purpose |
|---|---|
| id | PK |
| candidate_owner_company_id | Permanent owner |
| first_name | |
| last_name | |
| Unique | |
| phone | |
| location | |
| headline | |
| skills | |
| protection_flag | public / protected / private |
| status | lifecycle |
| next_available_date | |
| last_placement_id | FK |
| created_at | |
| updated_at |
net_submissions
| Field | Purpose |
|---|---|
| id | PK |
| job_id | FK |
| candidate_id | FK |
| submitting_company_id | Who submitted |
| candidate_owner_company_id | Stored copy |
| candidate_manager_company_id | Managing recruiter |
| submission_type | recruiter / candidate |
| split_flag | 1/0 |
| status | pipeline state |
| created_at | |
| updated_at |
net_placements
| Field | Purpose |
|---|---|
| id | PK |
| submission_id | FK |
| job_id | |
| candidate_id | |
| placement_type | contract / perm |
| placement_fee | Gross |
| network_fee | 10% |
| recruiter_share_total | fee minus network |
| primary_company_share | |
| secondary_company_share | |
| payment_status | pending / paid |
| start_date | |
| guarantee_days | |
| lock_until_date | |
| next_available_date | |
| created_at | |
| updated_at |
net_activity_log
| Field | Purpose |
|---|---|
| id | PK |
| entity_type | candidate / job / submission |
| entity_id | |
| action | event name |
| performed_by | user id |
| meta | JSON |
| created_at |
Step 2 — Spreadsheet Field Mapping (1-to-1)
Here is his spreadsheet sample:
| Spreadsheet Field | Example | Mapping |
|---|---|---|
| Company ID | 458 | net_companies.external_company_id (NEW FIELD NEEDED) |
| Company Name | Alaska Regional Hospital AK | net_companies.name |
| City | Anchorage | net_jobs.location |
| Date Created | 2/20/2024 | net_jobs.created_at |
| Working Owner | Claudia Pierre | net_users (must match recruiter user) |
| Quantity | 1 | net_jobs.quantity (NEW FIELD NEEDED) |
| Positions Filled | 0 | net_jobs.positions_filled (NEW FIELD NEEDED) |
| Division | MOUNTAIN DIVISION (15) | net_jobs.division_name + division_code (NEW FIELD NEEDED) |
IMPORTANT — Fields Missing From Current Schema
Your instinct was correct.
We need to expand net_jobs to support:
Add These Fields:
external_job_id (nullable)
external_company_id (nullable)
division_name
division_code
quantity
positions_filled
job_reference_code
source_type (spreadsheet / reflik / manual)
source_document_path
These are operational fields.
They are not ATS fluff.
They are business-tracking critical.
External Job Numbers
Yes — add:
external_job_id VARCHAR(100)
Even if blank initially.
Because later:
- Reflik will have external IDs
- Other vendors may have external IDs
- You need mapping control
Department / Division
Your example:
MOUNTAIN DIVISION (15)
We should split that into:
- division_name = MOUNTAIN DIVISION
- division_code = 15
That gives reporting flexibility.
Details from Separate Doc
Noted:
Details are in separate formatted doc.
Best approach (Phase 1 simple version):
Add to net_jobs:
description_document_path
Store document in:
/engine/job_docs/{external_job_id}.pdf
Later, you can parse structured sections if needed.
But linking is fine for MVP.
Missing Concept — Client vs Company
His spreadsheet “Company Name” likely means:
Client.
But in our engine:
Company = Agency.
So we need:
NEW TABLE:
net_clients
| Field | Purpose |
|---|---|
| id | PK |
| name | Client name |
| external_client_id | from spreadsheet |
| city | default city |
| division | optional |
| created_at |
Then:
net_jobs.client_id → FK net_clients.id
This keeps agencies and clients separate.
That is critical.
Final 1-to-1 Mapping Summary
| Spreadsheet Column | Engine Target |
|---|---|
| Company ID | net_clients.external_client_id |
| Company Name | net_clients.name |
| City | net_jobs.location |
| Date Created | net_jobs.created_at |
| Working Owner | net_users.wp_user_id → mapped recruiter |
| Quantity | net_jobs.quantity |
| Positions Filled | net_jobs.positions_filled |
| Division | net_jobs.division_name + division_code |
Strategic Insight Correct
Build ingestion from his spreadsheet first.
Why?
Because:
- No scraping required
- No API battles
- Clean structured input
- Immediate value
- Controlled testing
- Revenue source already active
Reflik comes later.
PART 1 — NEW FIELDS ADDED (AND WHY)
These are fields added beyond the original core schema to support your son’s spreadsheet and real-world operations.
A) Added to net_jobs
1. external_job_id
Type: VARCHAR(100)
Why:
Allows tracking of job IDs from:
- Spreadsheet
- Reflik
- Vendor ATS
- Future integrations
This ensures we never lose alignment with external systems.
2. external_client_id
Type: VARCHAR(100)
Why:
Maps to spreadsheet “Company ID” (which is actually Client ID).
Prevents duplicate client creation during imports.
3. division_name
Type: VARCHAR(255)
Why:
Stores “MOUNTAIN DIVISION” portion of:
MOUNTAIN DIVISION (15)
Used for reporting and grouping.
4. division_code
Type: VARCHAR(50)
Why:
Stores the numeric part “15”.
Useful for internal reporting or matching future data feeds.
5. quantity
Type: INT
Why:
From spreadsheet “Quantity” column.
Represents number of openings for this job.
This is critical for multi-placement tracking.
6. positions_filled
Type: INT
Why:
Tracks how many placements have been made against the job.
Prevents oversubmitting once job is filled.
7. job_reference_code
Type: VARCHAR(100)
Why:
Internal reference if needed (future-proofing).
Optional but useful for manual tagging.
8. source_type
Type: ENUM(‘spreadsheet’,’reflik’,’manual’,’api’)
Why:
Tracks where the job came from.
Important for:
- Performance tracking
- Data quality analysis
- Revenue source tracking
9. description_document_path
Type: VARCHAR(512)
Why:
Since job details live in separate formatted document.
Instead of pasting full text, we link to stored file.
B) New Table: net_clients
This is critical because:
Spreadsheet “Company Name” = CLIENT
Not recruiting agency.
So we separate:
Agency (member company)
Client (hospital, employer, etc.)
Fields for net_clients
| Field | Purpose |
|---|---|
| id | Internal PK |
| name | Client name |
| external_client_id | Spreadsheet ID (458) |
| city | Default city |
| division | Optional |
| created_at | Timestamp |
This keeps structure clean and scalable.
Summary of Added Elements
New Fields in net_jobs:
- external_job_id
- external_client_id
- division_name
- division_code
- quantity
- positions_filled
- job_reference_code
- source_type
- description_document_path
New Table:
- net_clients
Nothing excessive. All practical.
PART 2 — SYSTEM OVERVIEW IN PLAIN ENGLISH (LOW LEVEL)
Now let’s explain how this works in simple but complete terms.
What This System Actually Is
This is NOT:
- A public job board
- A recruiter marketplace
- An ATS replacement
- A free-for-all
This IS:
A private, invite-only recruiting network
where:
- Agencies collaborate
- Candidates remain owned
- Jobs can be shared
- Revenue is split automatically
- Trust is enforced by system rules
Step-by-Step: How It Works
1. Agencies Join (Invite Only)
Only trusted agencies are invited.
They:
- Have their own company record
- Have their own recruiters
- Have their own candidates
They do NOT lose ownership of anything.
Ownership is permanent.
2. Job Enters System
A job comes in from:
- Your son’s spreadsheet
- MyNiceJob via JobPipe
- Manual entry
- Future integration
System stores:
- Client
- Division
- Quantity
- Owner
- Primary recruiter (optional)
- Visibility settings
3. Job Visibility Model
When job is created:
It may be:
- Exclusive to primary recruiter for X days
- Visible to selected agencies
- Open to all network members
This is controlled and logged.
Not chaotic.
4 Candidate Ownership
Every candidate has:
- Permanent owner company
- Protection level:
- public_network
- protected
- private
No one can steal a candidate.
Even if another recruiter places them,
the original owner remains owner.
That’s the trust backbone.
5 Submissions
When a recruiter submits:
System checks:
- Is job open?
- Is candidate available?
- Is this duplicate?
- Is protection flag valid?
If allowed:
Submission is created.
If another recruiter submitted same candidate to same job:
Blocked.
If multiple recruiters submit same candidate to different jobs:
Allowed.
6 Split Logic
If:
- Job had a primary recruiter
- Secondary recruiter submits candidate
- Candidate is placed
Then:
System auto splits.
No debate.
No negotiation.
No politics.
System enforces 50/50.
7 Placement
When candidate is hired:
System:
- Creates placement record
- Calculates 10% network fee
- Calculates recruiter shares
- Locks candidate for guarantee period
- Sets next_available_date
Candidate enters lifecycle engine.
8 Lifecycle
After placement:
- Locked during guarantee
- Locked during contract
- 15-day pre-market window
- Released to network again
This creates recurring revenue.
Why This Is Different From Other Systems
Most ATS systems:
- Are single-agency
- No split enforcement
- No lifecycle automation
- No shared governance
- No network revenue layer
Public job boards:
- No ownership protection
- No trust layer
- No revenue alignment
This system:
- Protects ownership
- Allows sharing
- Automates splits
- Tracks lifecycle
- Encourages collaboration
- Pays network 10%
- Keeps politics out of it
It’s structured collaboration.
Revenue Model (Simple Explanation)
Example:
Placement Fee: $40,000
Network fee (10%): $4,000
Remaining: $36,000
If split:
- $18,000 to each side
If no split:
- $36,000 to one side
Network always earns 10%.
More collaboration = more placements = more network revenue.
Trust Mechanism
Trust is enforced by:
- Permanent candidate ownership
- Audit trail
- Submission uniqueness rule
- Automatic split logic
- Locked lifecycle states
- No manual override abuse
- Clear visibility rules
Trust is not emotional.
It is structural.
Why This Model Scales
Because:
- Agencies don’t lose control
- Collaboration is incentivized
- System prevents duplicate chaos
- Revenue is automatic
- Data structure is clean
- Spreadsheet ingestion works now
- Reflik can be added later
It grows from inner circle outward.
The Big Picture
You are not building a job board.
You are building:
A private recruiting liquidity exchange
with automated revenue alignment.
That is rare.
And powerful.
What This Is NOT
This is NOT:
- A job board
- A CRM replacement
- An ATS clone
- A marketplace
- A system that takes control away from him
It is infrastructure.
And infrastructure should make him stronger, not smaller.
Why This Is Different From a Job Board
A job board:
- Is public
- Is anonymous
- Has no ownership protection
- Has no split enforcement
- Has no lifecycle control
- Is transactional
- Generates low-trust interactions
This system:
- Is private
- Invite-only
- Enforces candidate ownership
- Prevents duplicate submissions
- Automates split logic
- Tracks placement lifecycle
- Builds internal liquidity
A job board increases noise.
This system increases conversion.
Why This Is Different From a CRM or ATS
A CRM/ATS:
- Is single-agency
- Tracks your pipeline
- Manages your candidates
- Does not understand multi-agency cooperation
- Does not handle split-desk enforcement
- Does not protect candidate ownership across orgs
- Does not automate revenue alignment
This system:
- Is multi-agency aware
- Protects ownership across companies
- Allows shared job visibility
- Enforces split logic automatically
- Prevents internal disputes
- Tracks candidate reactivation cycles
- Aligns incentives at network level
An ATS is inward-facing.
This system is liquidity-facing.
The Real Difference
Traditional recruiting tools optimize:
Individual recruiter productivity.
This system optimizes:
Network-level placement velocity.
That’s a completely different objective.
Still Operate the Same
You can:
- Keep using spreadsheets
- Keep owning client relationships
- Keep assigning recruiters
- Keep deciding exclusivity
- Keep managing interviews
- Keep negotiating fees
Nothing in day-to-day sales behavior has to change.
What changes is:
The enforcement and structure behind it.
What the System Automates
Right now probably:
- Manually tracks who submitted what
- Manually resolves split disputes
- Manually tracks candidate reuse
- Manually monitors open positions
- Manually reactivates candidates
- Manually calculates revenue splits
- Manually tracks who should get credit
The system automates:
- Submission uniqueness
- Split triggers
- Revenue calculations
- Lifecycle locking
- Candidate reactivation timing
- Visibility permissions
- Audit logging
- e still hunts.
- He still closes.
- He still negotiates.
The system prevents leakage and disputes.
What Gets Easier
- No more accidental duplicate submissions.
- No more confusion about ownership.
- No more “who gets credit?” arguments.
- No more tracking placements in disconnected sheets.
- No more losing track of reactivatable candidates.
- No more internal politics over splits.
That reduces friction.
What Gets Bigger
This is the part he must understand.
When friction drops:
Volume rises.
When volume rises:
He becomes busier — but on higher-value work.
Instead of:
- Administrative resolution
- Tracking spreadsheets
- Mediating recruiter disputes
What should happen
- Managing higher placement flow
- Scaling agency participation
- Expanding client reach
- Growing the network
Busy, but strategic.
Why Network Performance Increases
Because:
- Candidates become reusable assets, not one-time placements.
- Multiple agencies can contribute without chaos.
- Primary windows create fairness.
- Split logic reduces conflict.
- Reactivation windows create repeat revenue.
- Internal search reduces LinkedIn cold sourcing dependency.
More collaboration → More submissions → More placements.
The Psychological Barrier
The fear is:
“If I share jobs, I lose control.”
The reality is:
Control increases because rules are enforced.
Ownership remains permanent.
Primary windows protect him.
Audit logs protect him.
Split math is automatic.
This is structured sharing, not open sharing.
Why It Is Better
It solves three real-world recruiting problems:
- Trust breakdown
- Duplicate chaos
- Revenue disputes
Most networks fail because:
They rely on goodwill.
This system relies on enforced rules.
The Big Mental Shift
Right now:
Operating as a strong independent operator.
This system allows him to operate as:
A liquidity hub.
He still owns relationships.
But now:
His placements can multiply through controlled collaboration.
The Revenue Multiplier
If he places:
1 job/month manually → 12/year
With a functioning network:
- Internal sourcing improves
- Time to fill decreases
- Collaboration increases fill rate
- Reactivation cycles increase repeat revenue
Even a 30% increase in fill rate changes everything.
If volume doubles:
The 10% network fee becomes meaningful.
But more importantly:
The placements scale.