Skip to main content

​
Implementation Overview

Implementation Type: Hybrid (Tracker + Workable via Kombo)
Note Format: Plain Text
Status: Production Ready
Customer-Specific Implementation
This client is hardcoded for MW Resources and should not be used for other organizations without modification.

​
Configuration

PropertyValue
Provider Enumtracker_workable
Note FormatPLAIN
Disposition ReasonsNot Supported (inherited from Tracker)
All Application StagesNot Supported (inherited from Tracker)
ArchitectureHybrid - Tracker base + Workable applications

​
Architecture

This is a specialized hybrid client that combines two data sources:
  1. Tracker ATS - Primary system for all operations
  2. Workable (via Kombo) - Application data only

​
Data Flow

Workable Applications → Kombo → Tracker Workable Wrapper → Tracker ATS
                                                          ↓
                                            All other operations → Tracker API

​
Inheritance

MwResourcesWorkableTrackerWrapperClient
  ↓ extends
TrackerAtsClient
  ↓ extends
BaseAtsClient

​
Feature Summary

Streaming Operations (Hybrid)

​
Stream Jobs

Status: Supported (Tracker)
Inherits job streaming from TrackerAtsClient.

​
Stream Applications

Status: Supported (Hybrid - Custom Override)
Method: _stream_applications(updated_after, for_job_ids)Custom Implementation:
Overrides the base Tracker implementation to:
  1. Fetch applications from Workable via Kombo
  2. Fetch applications from Tracker
  3. For Workable applications:
    • Find or create corresponding candidate in Tracker
    • Create application record in Tracker if needed
    • Map Workable data to Tracker structure
  4. Return combined application set

​
Stream Candidates

Status: Supported (Tracker)
Inherits candidate streaming from TrackerAtsClient.
All application management operations use Tracker functionality:
  • Move to Stage (Supported via Tracker)
  • Get Rejection Reasons (Not Supported - Tracker limitation)
  • Reject Applications (Limited via Tracker)
  • Create Applications (Supported via Tracker)
  • Get All Stages (Not Supported - Tracker limitation)
All job operations use Tracker:
  • Get Job by ID (Supported)
  • Get Enhanced Job (Supported)
  • Batch Job Operations (Supported)

​
Get Candidate by ID

Status: Supported (Tracker)

​
Find Candidates by Details

Status: Supported (Tracker)Implementation Notes:
Custom method _ensure_candidate_exists_in_tracker() searches Tracker for candidates and creates them if needed when processing Workable applications.

​
Get Resume

Status: Supported (Tracker)
All notes and attachments operations use Tracker:
  • Application Notes (Supported)
  • Candidate Notes (Supported)
  • Application Attachments (Supported)
  • Candidate Attachments (Supported)
All custom field operations use Tracker’s implementation.

​
Implementation Notes

​
Workable Integration

Uses TrackerWorkableWrapperKomboClient - a specialized Kombo client for accessing Workable data.

​
Candidate Mapping

When encountering a Workable application:
  1. Extract candidate info (name, email, phone)
  2. Search for candidate in Tracker by details
  3. If not found, create candidate in Tracker
  4. Link application to Tracker candidate

​
Phone Number Normalization

Uses normalize_phone_for_comparison() to match candidates across systems despite formatting differences.

​
Application Status Mapping

Maps Workable application outcomes to Tracker:
  • HIRED → Accepted
  • REJECTED → Declined
  • Other outcomes → Appropriate Tracker statuses

​
Hybrid Streaming Logic

The _stream_applications() override: 
async def _stream_applications(self, updated_after, for_job_ids):
    # 1. Get Workable applications via Kombo
    workable_apps = await self.kombo_client.stream_applications(...)
    
    # 2. For each Workable application:
    #    - Find/create candidate in Tracker
    #    - Create application in Tracker if needed
    
    # 3. Get Tracker applications
    tracker_apps = await super()._stream_applications(...)
    
    # 4. Return combined set (deduplicated)

​
Known Limitations

MW Resources Specific
This implementation is hardcoded for MW Resources’ specific workflow. Do not use for other organizations.
Tracker Limitations Apply
Inherits all limitations from TrackerAtsClient:
  • No rejection reason enumeration
  • No stage enumeration
  • Timezone handling quirks
Workable Data is Read-Only
Applications from Workable are synced to Tracker. All write operations go to Tracker, not back to Workable.

​
Use Case

This hybrid client enables MW Resources to:
  • Receive applications from Workable (where candidates apply)
  • Store and manage all data in Tracker (system of record)
  • Use Tenzo with their existing dual-system workflow
  • Implementation: server/ats/tracker_ats/mw_resources_workable_tracker_wrapper_client.py (~400 lines)
  • Kombo Client: server/ats/tracker_ats/tracker_workable_wrapper_kombo_client.py
  • Documentation: server/ats/tracker_ats/MW_RESOURCES_WORKABLE_TRACKER_IMPLEMENTATION.md
  • Base Client: server/ats/tracker_ats/tracker_ats_client.py
  • Parent Base: server/ats/base_ats_client.py

​
See Also