LinkedIn Job Agent

Job hunting often feels repetitive.

Every day starts the same way: search for roles, open dozens of job listings, identify companies worth applying to, find the hiring manager or recruiter, copy links into a spreadsheet, and somehow keep track of everything before repeating the process again tomorrow.

After doing this manually for weeks, I realized I was spending more time collecting opportunities than actually preparing good applications. The process itself had become the bottleneck.

I started wondering whether the entire workflow could be automated.

That question eventually became LinkedIn Job Agent, a personal AI-powered job discovery platform that continuously searches LinkedIn, discovers hiring contacts, organizes opportunities inside Google Sheets, and exposes everything through a FastAPI backend with Telegram and n8n integrations.

The complete source code is available on GitHub.

The Goal

The objective wasn't to scrape LinkedIn for the sake of automation.

It was to reduce the repetitive work involved in finding opportunities so that I could spend more time researching companies, tailoring resumes, and reaching out to recruiters.

Rather than building another job board, I wanted a system that continuously answered a few practical questions:

• What new roles match my interests?
• Who is hiring for those roles?
• Have I already seen this opportunity?
• Where am I in the application process?

The result is a workflow that combines job discovery, contact identification, and opportunity management into a single pipeline.

System Architecture

The platform is built as a collection of independent components that communicate through APIs.

                           Telegram
                               │
                               ▼
                    Local LLM (Qwen via Ollama)
                               │
                               ▼
                          FastAPI Backend
                               │
          ┌────────────────────┼────────────────────┐
          ▼                    ▼                    ▼
 LinkedIn Job Agent      Google Sheets         CSV Export
          │
          ▼
   LinkedIn Jobs
          │
          ▼
 Opportunity + Contact Discovery

                ▲
                │
             n8n Workflows
       (Scheduling & Automation)

Keeping each component independent makes the platform easier to extend while allowing every part of the workflow to evolve without affecting the others.

Building the Pipeline

The heart of the project is a Playwright-based LinkedIn collector that automates job discovery using a persistent Chrome profile. Once authenticated, the browser session is reused across future runs, removing the need to log in every time the scraper executes.

Each run begins by searching LinkedIn using configurable job titles and locations. The scraper collects job information before attempting to discover hiring contacts such as recruiters, hiring managers, or job posters associated with the opportunity.

After collecting the data, duplicate opportunities are merged and synchronized to Google Sheets, creating a single source of truth for tracking applications. An optional CSV export is also generated for local backups or further analysis.

Instead of producing isolated outputs, every run contributes to an evolving database of opportunities.

Why FastAPI?

As the project grew, it became clear that scraping should be separated from the interfaces interacting with it.

Rather than allowing every component to access the scraper directly, I introduced a FastAPI backend that exposes the functionality through APIs. This creates a clean boundary between data collection and user interaction.

The Telegram bot, n8n workflows, and any future applications communicate with the backend instead of depending on the scraping logic itself. This separation makes the system significantly easier to maintain and provides flexibility for adding additional interfaces later.

Adding Local AI

The project also experiments with running a local language model using Ollama.

Instead of performing the scraping itself, the model focuses on understanding user intent and translating natural language requests into structured actions. This keeps the language model responsible for reasoning while leaving deterministic business logic to the application.

Separating those responsibilities makes the system easier to reason about and avoids using AI where traditional software performs better.

Automating the Workflow

One of the goals was to eliminate the need to manually trigger the scraper every day.

To achieve this, I integrated n8n as the orchestration layer.

Scheduled workflows can trigger job collection, synchronize new opportunities, and notify me through Telegram whenever matching roles are discovered. Since everything communicates through FastAPI, new automation workflows can be added without modifying the scraper itself.

This architecture turns the project from a standalone script into an extensible automation platform.

What I Learned

This project started as a LinkedIn scraper but gradually became an exercise in system design.

Breaking the application into independent services made it significantly easier to extend than keeping everything inside a single script. FastAPI became the communication layer, Playwright focused solely on data collection, Google Sheets handled persistence, Telegram became the user interface, and n8n orchestrated the entire workflow.

Another important lesson was recognizing where AI adds value and where it doesn't. The language model isn't responsible for scraping websites or managing application state. Its role is understanding intent and making interactions more natural, while the surrounding software handles deterministic workflows.

Perhaps the biggest takeaway was that automation is rarely about writing a single script. It's about designing systems where each component has one clear responsibility and can evolve independently.

Current Status

The platform currently supports automated LinkedIn job collection, hiring contact discovery, Google Sheets synchronization, CSV exports, FastAPI APIs, Telegram interaction, and scheduled execution using n8n.

Future work includes expanding beyond LinkedIn Jobs into hiring posts, company career pages, AI-generated job summaries, recruiter outreach workflows, resume matching, analytics, and a dedicated web dashboard.

Rather than becoming another job search application, the long-term vision is to build a modular platform that continuously discovers opportunities, organizes them intelligently, and automates as much of the application workflow as possible.