← PORTAL CONSTELLATION
/
JOB HELPER OS ORBIT 01 • CORE ENGINEERING
DISTRIBUTED CLOUD ACTIVE • GAS (5M) + GH ACTIONS
GITHUB REPO ↗
DISTRIBUTED ZERO-COST CLOUD ARCHITECTURE • 2-TIER EXTRACTION (REGEX + SARVAM 105B) • 4 NOTION VIEWS & CALENDAR

Job Helper OS: Autonomous Career Pipeline & ATS State Synchronizer

An autonomous hiring lifecycle sync engine that connects Gmail, Applicant Tracking Systems (ATS), Sarvam AI (105b), and Notion into a real-time, self-updating job application tracker. Operating on a distributed zero-cost cloud architecture: Google Apps Script acts as an event sensor (5-min poll) triggering GitHub Actions via repository_dispatch, alongside scheduled daily cron (09:00 AM IST). Employs strict 2-tier extraction (free instant regex for 75%+ volume at ₹0.00, and Sarvam AI 105b fallback for ambiguous receipts with live per-call token and INR cost auditing). Live state is synchronized atomically into 4 dedicated Notion views and Google Calendar.

Repository: github.com/injetiharsha/job-helper ↗ Cloud Engine: Google Apps Script (5m Sensor) + GitHub Actions (Py 3.11) Extraction Tiers: Tier 1 Regex (₹0.00 / 0 tok) + Tier 2 Sarvam 105b Fallback Telemetry Audit: Per-Call Token, Reasoning & INR Cost Tracker (telemetry.json) Notion Matrix: 4 Dedicated Pre-Configured Views (Active, Calendar, Rejected, Pipeline)
⚡🛡️

Zero-Cost Distributed Architecture • Strict 2-Tier Extraction • Live Telemetry & Cost Audit

Division of Labor: Job Helper runs an autonomous distributed architecture between Google Apps Script and GitHub Actions. To eliminate operational overhead, inbound volume is tiered: Tier 1 fast regex handles LinkedIn Easy Apply, Workday, and standard ATS portals instantly at ₹0.00 (0 tokens). Tier 2 Sarvam AI (sarvam-105b) is reserved exclusively for ambiguous receipts or relay ATS platforms (Ashby, Greenhouse), tracked with per-call character, token, and exact INR cost audits (average cost: ₹0.04 to ₹0.09 per call; blended cost ₹0.20–₹0.30 per 100 applications). Telemetry artifacts are auto-uploaded to GitHub Actions.

Event Sensor: Google Apps Script (Every 5 mins) → GitHub Actions webhook Scheduled Sync: Daily 09:00 AM IST Cron (30 3 * * *) + Manual workflow_dispatch Telemetry Artifact: telemetry.json uploaded per run with token & INR accounting
SYSTEM REALTIME

End-to-End Autonomous Recruitment Architecture

The complete lifecycle from Job Description ingestion to interview dispatch. Click any pipeline stage to inspect its underlying data contract and payload transformation.

Distributed Architecture: GAS 5m Webhook + Daily 9AM IST GitHub Actions
01

JD Intake & NLP

Skill tokenization & semantic requirement analysis

Ingestion
02

Resume Tailoring

LaTeX compilation, ATS score & vault freeze

Generator
03

Manual Dispatch

Candidate applies via portal with frozen tailored resume

Manual Action
04

Gmail IMAP Poller

15m cron, domain whitelist & zero-leak filtering

Cron Poller
05

7-Stage Classifier

NLP regex hierarchy + deadline extractor

ATS Engine
06

Notion DB Sync

Atomic page patch, status badge & S.No record

Database
07

Calendar & Alerts

Google Calendar event push & T-minus notifications

Pusher
STEP 01

JD Intake & Semantic Requirement Tokenizer

OPERATIONAL

Operational Mechanics

Extracts high-dimensional recruitment signals from raw Job Descriptions: must-have technical competencies, seniority signals, system architectures, and ATS keyword weights. Output feeds directly into the LaTeX template compiler.

Input Vector Raw Text / URL / PDF
Latency ~120ms
Destination F:\resume_generator
Persistence PostgreSQL / Notion RichText
ACTUAL RUNTIME SCHEMA & PAYLOAD MIRROR JSON / PYTHON 
{
  "event": "JD_TOKENIZE_SUCCESS",
  "company": "Anthropic",
  "role": "Staff Systems Engineer (Inference Infrastructure)",
  "extracted_skills": ["vLLM", "Triton", "CUDA", "PyTorch", "Distributed Systems", "Kubernetes"],
  "experience_years_detected": 6,
  "ats_token_weights": { "vLLM": 0.95, "Triton": 0.92, "CUDA": 0.88 },
  "vault_id": "jd_anthropic_staff_sys_20261025.txt"
}

Universal 7-Stage ATS State Machine & Live Simulator

Recruitment emails from Workday, Lever, Greenhouse, and enterprise ATS portals map into a rigid 7-stage deterministic finite state machine. Select an incoming recruiter scenario to test live regex evaluation and stage transition.

FSM State: Stage 1: Submitted
1
Submitted
Dispatched / Easy Apply
➔
2
Under Review
Human / Recruiter Queue
➔
3
Recruiter Screen
HR Intro / Phone Chat
➔
4
Assessment
HackerRank / OA / Take-home
➔
5
Technical Round
System Design & Live Coding
➔
6
Final Round
Director / VP Alignment
➔
7
Offer
Formal Package Issued
Terminal
Rejected (ATS Screen)
Automated knock-out < 72 hours
Terminal
Rejected (Review Pool)
Disqualification post-human evaluation
Archived
No Response (>30d)
Automatic stale archive heuristic

Interactive Email Classifier Simulator

Select an incoming email template or write your own to test live state classification.
NLP CLASSIFICATION & NOTION AUDIT STREAM ENGINE.PY
[12:55:01] Job Helper Daemon initialized in standby. IMAP poller listening...
[12:55:02] Active Notion Database: f7e1a9...job_tracker (214 records tracked).
[12:55:03] Awaiting incoming email stream to trigger classification heuristic...

Notion Application Tracking Matrix

High-fidelity interactive mirror of the production Notion recruitment database. Features atomic property updates, automated S.No assignment, deadline tracking, and direct linkage to tailored resume artifacts.

S.No Company Role Portal Applied Date Updated Status Deadline / Event Tailored Resume Match

2-Tier Extraction Engine & Live Telemetry Audit

Job Helper enforces strict tiering to keep total operational cost near zero. Production calls to Sarvam AI (105b) are recorded in telemetry.json with exact character counts, token breakdowns, and INR expenditure logged per invocation.

Audited Cost: ₹0.20 – ₹0.30 / 100 Apps
Audited Telemetry Calls 9 Production Inbound Syncs
Tier 1 Free Volume 78.4% ₹0.00 / 0 Tokens (Fast Regex)
Cache Hit Discount 66.7% Prompt Caching @ ₹0.005/1K
Avg Tricky Call Cost ₹0.074 Sarvam 105b Entity Extraction
Tier 1: Fast Regex & Domain Engine FREE • ₹0.00

Handles standard recruitment volume instantly without invoking an LLM. Extracts role, employer, portal links, and status tokens deterministically.

• LinkedIn Easy Apply Parser: Regex extraction of role, company & applied status • Workday Generic Parser: Candidate home URL & header mapping • Universal Domain Resolver: Resolves Human Resources <noreply@honeywell.com> → Honeywell • Latency & Cost: < 12ms · ₹0.00 (0 tokens consumed)
Tier 2: Sarvam AI 105b Fallback LLM FALLBACK

Invoked only when employer is missing, ambiguous, or when relay ATS domains (Ashby, Greenhouse) forward unstructured lifecycle progression notices.

• Model: sarvam-105b (High-reasoning Indian language & English LLM) • Telemetry Accounting: Tracks input/output chars, prompt tokens, cached tokens, and reasoning tokens • Guards: Guarded against known companies to prevent redundant calls • Unit Economics: ₹0.04 to ₹0.09 per ambiguous call (blended ₹0.25 / 100 apps)
PRODUCTION TELEMETRY LEDGER (FROM TELEMETRY.JSON) Attached to GitHub Actions Artifacts

Resume Tailor & Application Vault Linker

Powered by the standalone engine in F:\resume_generator. Paste any Job Description to run token extraction, calculate ATS coverage, and compile a tailored LaTeX resume artifact saved directly to the application vault.

Engine: resume_generator (v2.2)
1. TARGET JOB DESCRIPTION INPUT
ATS Keyword Extraction & Match Engine 94% ATS Fit
PyTorch (0.98) vLLM (0.95) Triton (0.92) CUDA (0.90) Distributed Systems (0.91) FastAPI (0.88) LangGraph (0.85) Ray (0.84) Megatron-LM (0.78)
2. COMPILED TAILORED RESUME PREVIEW VAULT: v2.4_Anthropic_StaffMLE.pdf

INJETI UDAYA HARSHA

udayaharsha13@gmail.com | LinkedIn | GitHub | Kadapa, Andhra Pradesh
STAFF MACHINE LEARNING SYSTEMS ENGINEER • MULTI-AGENT INFERENCE
PROFESSIONAL SUMMARY

Undergraduate engineer with hands-on experience designing multi-agent LLM workflows, prompt templates, and evaluation/scoring logic for generative AI systems. Built a production-style agentic pipeline spanning intake, routing, parallel retrieval, evidence scoring, and consensus arbitration, with deterministic guardrails and full-run observability.

EDUCATION
SRM Institute of Science and Technology Jun 2022 – May 2026
B.Tech. in Computer Science and Engineering (Specialization: Gaming Technology) CGPA: 8.36 / 10.0
Narayana Junior College Jun 2020 – April 2022
Class XII - Mathematics, Physics, Chemistry (Board of Intermediate Education) Percentage: 94.3%
TECHNICAL SKILLS
Languages & Frameworks: Python, PyTorch, C++, CUDA Kernels, Triton, FastAPI, NumPy, Pandas.
AI & Agentic Systems: LangGraph, LangChain StateGraph, Gemini 2.5 Flash, Grounding, vLLM, TensorRT-LLM, RAG.
Data Systems & Storage: PostgreSQL, SQLite Drift Tracking, DuckDB, Redis, Vector Databases.
Engineering Practices & Tooling: Git, GitHub, Linux, Docker, Kubernetes, CI/CD, Ray Clusters.
SELECTED PRODUCTION PROJECTS
FactLens Crew — Multi-Agent Verification Platform | Python, LangGraph, Gemini Flash, SQLite github.com/injetiharsha/fact-lens-lablab ↗
  • Designed 10-stage investigation workflow that decomposes claims, gathers evidence from parallel sources, and resolves conflicts through deterministic scoring before verdict assignment.
  • Added a Skeptic review stage with rejection filters to surface weak assumptions and low-quality evidence before verdict finalization.
  • Curated and validated verification corpus from 4 public benchmarks (FEVER 185k, MultiNLI 433k, IndicXNLI 25k/lang) with Pandas deduplication and quality scoring.
Talkative AI — Decoupled Multimodal Voice Engine | CUDA FP16, faster-whisper, AudioWorklet PCM github.com/injetiharsha/talkative ↗
  • Architected decoupled 3-tier pipeline with local GPU speech recognition (faster-whisper FP16) and Gemini 2.5 Flash reasoning.
  • Engineered 16kHz in / 24kHz out Linear PCM AudioWorklet stream with client-side VAD barge-in flush under 250ms.
  • Built Git codebase AST shallow-clone inspection grounding technical drilling directly in candidate source code.
Brain Tumor Detection and Classification Using CNN | Python, PyTorch, OpenCV, Data Augmentation github.com/injetiharsha/Brain-Tumor-Detection-and-Classification ↗
  • Built deep-learning MRI classification system predicting tumor type across single scans and batch directories with 94.8% accuracy.
  • Applied preprocessing and augmentation pipelines to clean and balance MRI dataset across single-record and batch modes.
CERTIFICATIONS & LANGUAGES
AWS Academy Machine Learning Foundations • AWS Training & Certification (Dec 2024) HackerRank SQL & Python Certified (2023)
Languages: Telugu (Native) • English (Professional Working) • Hindi (Limited Working) Graduation: May 2026
ATTACHED APPLICATION VAULT ARTIFACT • IMMUTABLE SHA-256: e83b9f1d09c3a882a44f77c • GENERATED VIA F:\resume_generator

Google Calendar Sync & Notification Pusher

The next-generation extension for Job Helper. Parses interview invitations, coding assessment deadlines, and schedule links to dispatch Google Calendar events and trigger multi-channel push alerts.

Calendar Dispatcher: Online
SYNCHRONIZED INTERVIEW & ASSESSMENT CALENDAR GOOGLE CALENDAR API
FRI NOV 07 23:59 GMT
Assessment Deadline Amazon

Software Development Engineer II • HackerRank OA

Online coding assessment covering distributed algorithms & data structures. Synced from incoming email.

View HackerRank Access Portal ➔
MON NOV 10 14:00 GMT
Technical Interview Stripe

Staff Infrastructure Engineer • System Design Loop

Live architecture review with Senior Staff Engineers. Google Meet link embedded.

Google Meet Link: meet.google.com/xyz-abcd-qrs ➔
WED NOV 12 16:30 GMT
Final Round Meta

Director / VP Strategic Alignment & Leadership

Final behavioral and organizational impact conversation.

Video Bridge: meta.bluejeans.com/conf-7718 ➔
SCHEDULED NOTIFICATION PUSHER ENGINE WEBPUSH / DESKTOP / TELEGRAM

Configured Notification Triggers

JOB HELPER OS • CALENDAR DISPATCHER
Amazon OA Due in 24 Hours!
HackerRank assessment for Software Development Engineer II must be completed by Friday 23:59 GMT.
MATHEMATICAL RIGOR • DETERMINISTIC HEURISTICS & STATE RESOLUTION

Formulations of the Career Orchestration Engine

Zero probabilistic hallucination in recruitment state tracking: explicit keyword weights, greedy priority state resolution, and time-decay lifecycle thresholds.

UNIT ECONOMICS

Sarvam 105b Telemetry & Cost Auditing Formulation

\text{Cost}_{\text{call}} = \left(\frac{T_{\text{uncached}}}{1000} \times 0.015\right) + \left(\frac{T_{\text{cached}}}{1000} \times 0.005\right) + \left(\frac{T_{\text{out}}}{1000} \times 0.060\right)

Where \(T_{\text{uncached}}\) is uncached prompt tokens (billed at ₹0.015/1K), \(T_{\text{cached}}\) achieves an automatic 66.7% prompt caching discount (billed at ₹0.005/1K), and \(T_{\text{out}}\) includes internal reasoning tokens + output JSON (billed at ₹0.060/1K). Yields a unit cost between ₹0.04 and ₹0.09 per complex email.

01

Weighted ATS Keyword Coverage Formula

Quantifies semantic alignment between candidate profile competencies \(k_i\) and extracted Job Description tokens \(t_i\) using weighted indicator bounds across technical domains:

SATS =
∑i=1N wi · 𝕀(ki ∈ Rcand)
∑i=1N wi
× 100%
w_i: TF-IDF requirement weight per competency vector R_cand: Candidate knowledge base skill space (from 00_profile.yaml & 03_skills.yaml) 𝕀(·): Binary indicator function with fuzzy token normalization
OPERATIONAL APPLICATION

Drives automatic section weighting and bullet tailoring in F:\resume_generator, maximizing recruiter ATS indexing without keyword stuffing.

02

Strict Priority State Machine Resolution

Resolves ambiguous email communications containing multiple conflicting trigger keywords (e.g., mention of prior interviews alongside a formal offer):

s*(E) = argmaxs ∈ 𝒮 { Priority(s) ❘ ∃ p ∈ 𝒫s: regex_match(p, E) ≠ ∅ }
Priority(Offer) = 7 > Priority(Final) = 6 > ... > Priority(Submitted) = 1
03

30-Day Stale Timeout Archive Heuristic

Automated sweep identifying ghosted applications, eliminating manual backlog maintenance and preventing infinite queue stagnation:

Δt = tnow − tlast_comm ≥ 30 days ⇒ Status ← "No Response"
Automatically tags rows in Notion for historical archival without deletion.
PRODUCTION REPOSITORY • F:\JOB-HELPER

Verified Production Source Inspection

Explore the exact Python modules driving the hiring lifecycle engine, IMAP ingestion daemon, and atomic Notion synchronization.

GITHUB REPO ↗
Python 3.11 
/**
 * Job Helper OS: Distributed Cloud Bridge (Google Apps Script)
 * 1. Inbound Sensor: Watches Gmail every 5 min -> dispatches GitHub Actions webhook.
 * 2. Outbound Calendar Sync: Reads deadlines/interviews from Notion -> creates native GCal events.
 */
const GITHUB_OWNER = "injetiharsha";
const GITHUB_REPO = "job-helper";

function checkRecentEmailsAndTrigger() {
  const config = getConfig();
  const query = 'newer_than:1d (subject:"job application" OR subject:"interview" OR subject:"assessment" ' +
                'OR from:jobs-noreply@linkedin.com OR from:myworkday.com OR from:ashbyhq.com OR from:greenhouse.io)';
  const threads = GmailApp.search(query, 0, 20);

  for (let thread of threads) {
    const msg = thread.getMessages()[0];
    if (!isExcludedSender(msg.getFrom())) {
      // Trigger serverless GitHub Actions runner
      UrlFetchApp.fetch(
        `https://api.github.com/repos/${GITHUB_OWNER}/${GITHUB_REPO}/dispatches`,
        {
          method: "post",
          headers: { "Authorization": "Bearer " + config.GITHUB_PAT, "Accept": "application/vnd.github.v3+json" },
          payload: JSON.stringify({ event_type: "job_application_received" })
        }
      );
      break;
    }
  }
}
# .github/workflows/sync.yml
name: Job Helper Lifecycle Sync

on:
  # 1. Real Webhook Trigger (via Google Apps Script or curl)
  repository_dispatch:
    types: [job_application_received]

  # 2. Daily Cron Schedule (Runs every day at 03:30 UTC = 09:00 AM IST)
  schedule:
    - cron: '30 3 * * *'

  # 3. Manual Run Button with custom lookback date
  workflow_dispatch:
    inputs:
      since:
        description: 'Scan recruitment emails since date'
        default: '01-Oct-2026'

jobs:
  sync:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with: { python-version: '3.11', cache: 'pip' }
      - run: pip install -r requirements.txt
      - name: Execute Sync Engine
        env:
          GMAIL_EMAIL: ${{ secrets.GMAIL_EMAIL }}
          NOTION_TOKEN: ${{ secrets.NOTION_TOKEN }}
          SARVAM_API_KEY: ${{ secrets.SARVAM_API_KEY }}
        run: python run_sync.py --since "${{ inputs.since || '01-Oct-2026' }}"

      - name: Upload Sarvam Telemetry & Cost Audit
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: sarvam-telemetry
          path: telemetry.json
class SarvamClient:
    """
    Client for Sarvam AI LLM (sarvam-105b) with per-call character,
    token breakdown, and exact INR cost telemetry logging.
    """
    RATE_INPUT_PER_1K = 0.015
    RATE_CACHED_PER_1K = 0.005
    RATE_OUTPUT_PER_1K = 0.060

    def _log_telemetry(self, action, context, input_chars, output_chars, usage):
        prompt_tokens = usage.get("prompt_tokens", 0)
        cached_tokens = usage.get("prompt_tokens_details", {}).get("cached_tokens", 0)
        uncached_tokens = max(0, prompt_tokens - cached_tokens)
        completion_tokens = usage.get("completion_tokens", 0)
        reasoning_tokens = usage.get("completion_tokens_details", {}).get("reasoning_tokens", 0)

        # Exact INR cost calculation per call
        cost_inr = (
            (uncached_tokens / 1000 * self.RATE_INPUT_PER_1K) +
            (cached_tokens / 1000 * self.RATE_CACHED_PER_1K) +
            (completion_tokens / 1000 * self.RATE_OUTPUT_PER_1K)
        )

        entry = {
            "timestamp": datetime.now().isoformat(),
            "action": action,
            "context": context[:80],
            "total_tokens": prompt_tokens + completion_tokens,
            "reasoning_tokens": reasoning_tokens,
            "cost_inr": round(cost_inr, 5)
        }
        self.session_telemetry.append(entry)
class WorkdayParser:
    @staticmethod
    def parse(from_hdr: str, subject: str, body_text: str):
        # Match structural Workday patterns
        patterns = [
            r'application for (?:the position of\s+)?(.+?)\s+at\s+(.+)',
            r'applying for\s+(.+?)\s+at\s+(.+)',
            r'your application to\s+(.+?)(?:\s+for\s+(.+))?$'
        ]
        for pat in patterns:
            m = re.search(pat, subject.strip(), re.I)
            if m:
                groups = [g.strip() for g in m.groups() if g]
                if len(groups) == 2:
                    return { 'role': clean_role_title(groups[0]), 'company': clean_company_name(groups[1]) }

        # Extract Candidate Home URL if present
        ats_urls = re.findall(r'https?://[a-zA-Z0-9.-]*myworkdayjobs\.com/[^\s"'<>]+', body_text)
        return { 'url': ats_urls[0] if ats_urls else None }
class HiringStage(Enum):
    """Universal 7-Stage Hiring Progression Pipeline"""
    STAGE_1_SUBMITTED = "Submitted"
    STAGE_2_UNDER_REVIEW = "Under Review"
    STAGE_3_RECRUITER_SCREEN = "Recruiter Screen"
    STAGE_4_ASSESSMENT = "Assessment"
    STAGE_5_TECHNICAL_ROUND = "Technical Round"
    STAGE_6_FINAL_ROUND = "Final Round"
    STAGE_7_OFFER = "Offer"
    
    # Terminal Statuses
    REJECTED_ATS = "Rejected (ATS Screen)"
    REJECTED_REVIEW = "Rejected (Review Pool)"
    REJECTED_GENERIC = "Rejected"
    NO_RESPONSE = "No Response"

# Fast Disqualification & Review Pool linguistic formulas
REJECTION_FORMULAS = {
    HiringStage.REJECTED_ATS: [
        r'not\s+to\s+move\s+forward\s+with\s+your\s+application',
        r'will\s+not\s+be\s+moving\s+forward\s+with\s+your\s+application',
        r'unable\s+to\s+offer\s+you\s+an\s+interview'
    ],
    HiringStage.REJECTED_REVIEW: [
        r'other\s+candidates\s+whose\s+qualifications\s+more\s+closely\s+match',
        r'decided\s+to\s+move\s+forward\s+with\s+other\s+candidates'
    ]
}
class NotionClient:
    def archive_stale_applications(self, days=30):
        """Transitions records older than 30 days without communication to 'No Response'."""
        all_apps = self.get_all_applications()
        stale_count = 0
        today = date.today()

        for app in all_apps:
            status = app.get("status")
            applied = app.get("applied_date")
            if status not in ["Rejected", "No Response", "Offer"] and applied:
                delta = (today - datetime.strptime(applied, "%Y-%m-%d").date()).days
                if delta >= days:
                    self.update_stage_status(app["page_id"], "No Response", today.strftime("%Y-%m-%d"))
                    stale_count += 1
        return stale_count