← Back to portfolio

Automated Job Intelligence System

Multi-source aggregation, AI-powered scoring, and zero-touch delivery — built end-to-end in n8n.

The problem

Manually job-hunting across six-plus remote job boards means repeating the same routine every day: opening tabs, skimming titles, filtering out irrelevant roles, checking if a listing was already seen yesterday, and estimating fit — all before even opening an application. At scale, that's hours lost every week to low-value, repetitive work.

The goal: build a system that does the searching, filtering, ranking, and reporting automatically — and only surfaces the opportunities actually worth a human's time.

The solution

An end-to-end n8n workflow runs unattended every weekday morning, pulls listings from six different sources in parallel, normalizes them into a single data model, filters by relevance, scores each one with an LLM against a specific candidate profile, and delivers a ranked digest straight to Telegram — with a persistent log in Google Sheets to avoid ever seeing the same listing twice.

Architecture overview

Schedule Trigger (weekdays, 8:00 AM)
        │
        ├── RemoteOK (REST API)
        ├── We Work Remotely (RSS)
        ├── Himalayas (RSS)
        ├── Remotive (REST API)
        ├── Dynamite Jobs (HTML)
        └── DailyRemote (HTML)
                │
        Merge All Sources
                │
        Normalize Jobs           → unifies 4 different data shapes into 1 schema
                │
        Filter by Keywords       → include/exclude logic on title + description + tags
                │
        Read Seen Jobs (Sheets)  → pulls historical log
                │
        Deduplicate              → drops anything already scored before
                │
        Detect Salary Range      → regex extraction when source omits salary
                │
        Prep AI Input            → builds a structured scoring prompt per listing
                │
        AI Scoring (Groq/Llama)  → rates fit 1–10 + reason + red flags
                │
        Rate-limit Wait
                │
        Parse Score + Sort       → top 7 ranked results
                │
        ├── Save to Sheets (audit log)
        └── Build Telegram Digest → formatted, emoji-coded, ready to read
                │
        Send to Telegram

Key engineering decisions

1. Heterogeneous source normalization

Each of the six sources returns data in a completely different shape: RemoteOK returns a JSON array with a metadata object in position 0, Remotive nests jobs inside a jobs array, the RSS feeds come as feed items, and two sources return raw HTML parsed with regex. Rather than building six separate downstream pipelines, a single normalization layer maps everything into one consistent job object — so every node after it doesn't need to know or care where the data came from.

2. Resilience by design

Every source node is configured to continue on error rather than halt the workflow — if one job board is down or changes its response format, the other five still flow through. No single point of failure across six external dependencies the team doesn't control.

3. Persistent deduplication

A Google Sheet acts as a lightweight "seen jobs" database. Every run reads the historical log first, builds a lookup set of previously-scored IDs, and filters new listings against it — with a safe fallback for the very first run when the sheet is empty. No duplicate alerts, no repeated scoring costs.

4. LLM-based relevance scoring, not keyword matching alone

Keyword filtering handles the obvious excludes and includes, but true fit assessment goes further: each surviving listing is sent to an LLM (Groq / Llama 3.1) with a structured prompt describing the target profile, and the model returns a strict JSON object with a 1–10 score, a one-line reason, and any red flags.

5. Fault-tolerant parsing

LLM output isn't always perfectly formed. The parsing step defensively handles malformed JSON, missing fields, and code-fence artifacts, falling back to the original job data so nothing silently disappears from the pipeline even when the model response is imperfect.

6. Human-first delivery

The final output isn't a spreadsheet row — it's a readable, emoji-coded Telegram message: green for strong fits, yellow for maybes, red for low scores, with salary, source, AI reasoning, and a direct apply link per listing. Even the empty-result case is handled gracefully rather than with silence.

Why it matters

This isn't a demo automation — it's a production system solving a real, recurring bottleneck: too much noise, not enough signal, in a repetitive daily task. The same architecture pattern — multi-source ingestion → normalization → AI-assisted filtering → persistent state → human-friendly delivery — applies directly to lead qualification, content curation, competitive monitoring, or any workflow where a team is drowning in raw data and needs a ranked, actionable shortlist instead.

---