> ## Documentation Index
> Fetch the complete documentation index at: https://f4c7a9e2d8b1-docs.tenzo.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Tracker Workable (MW Resources)

> Feature coverage and implementation details for MW Resources Workable-Tracker hybrid integration

## Implementation Overview

**Implementation Type:** Hybrid (Tracker + Workable via Kombo)\
**Note Format:** Plain Text\
**Status:** Production Ready

<Warning>
  **Customer-Specific Implementation**\
  This client is hardcoded for MW Resources and should not be used for other organizations without modification.
</Warning>

## Configuration

| Property               | Value                                         |
| ---------------------- | --------------------------------------------- |
| Provider Enum          | `tracker_workable`                            |
| Note Format            | `PLAIN`                                       |
| Disposition Reasons    | Not Supported (inherited from Tracker)        |
| All Application Stages | Not Supported (inherited from Tracker)        |
| Architecture           | Hybrid - 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

<AccordionGroup>
  <Accordion title="Streaming Operations (Hybrid)" defaultOpen>
    ### 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.
  </Accordion>

  <Accordion title="Application Management (Tracker-based)">
    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)
  </Accordion>

  <Accordion title="Job Management (Tracker-based)">
    All job operations use Tracker:

    * Get Job by ID (Supported)
    * Get Enhanced Job (Supported)
    * Batch Job Operations (Supported)
  </Accordion>

  <Accordion title="Candidate Management (Tracker-based with Workable mapping)">
    ### 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)
  </Accordion>

  <Accordion title="Notes & Attachments (Tracker-based)">
    All notes and attachments operations use Tracker:

    * Application Notes (Supported)
    * Candidate Notes (Supported)
    * Application Attachments (Supported)
    * Candidate Attachments (Supported)
  </Accordion>

  <Accordion title="Custom Fields (Tracker-based)">
    All custom field operations use Tracker's implementation.
  </Accordion>
</AccordionGroup>

## 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:

```python theme={null}
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

<Warning>
  **MW Resources Specific**\
  This implementation is hardcoded for MW Resources' specific workflow. Do not use for other organizations.
</Warning>

<Warning>
  **Tracker Limitations Apply**\
  Inherits all limitations from TrackerAtsClient:

  * No rejection reason enumeration
  * No stage enumeration
  * Timezone handling quirks
</Warning>

<Note>
  **Workable Data is Read-Only**\
  Applications from Workable are synced to Tracker. All write operations go to Tracker, not back to Workable.
</Note>

## 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

## Related Files

* 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

* [ATS Coverage Matrix](/internal/ats-coverage)
* [Tracker ATS](/internal/ats/tracker) - Base implementation