Building a workflow that searches four job boards and delivers results to Discord every 6 hours.

Last week I was laid off from Team Liquid after 3+ years as a IT Engineer.

The first few days were rough. Checking LinkedIn. Then Indeed. Then Glassdoor. Then back to LinkedIn. Repeat until exhausted.

By day three, I decided to automate the entire thing.

The Problem

Job searching is repetitive. Every day you're checking the same sites, running the same searches, scanning the same results. Most of the listings you've already seen. The new ones get buried. You miss things.

I wanted something that would:

  1. Search multiple job boards automatically
  2. Filter by my target roles and location
  3. Remove duplicates
  4. Deliver new listings to me (not the other way around)

The Solution: Job Radar

Job Radar is an n8n workflow that runs every 6 hours and posts matching jobs to a Discord channel. I wake up to fresh opportunities. No manual searching. No doom-scrolling.

Here's what a job card looks like in Discord:

┌─────────────────────────────────────────────┐
│ Senior DevOps Engineer                      │
├─────────────────────────────────────────────┤
│ 🏢 Company    📍 Location     💰 Salary    │
│ Acme Corp      Los Angeles, CA  $150-180K   │
├─────────────────────────────────────────────┤
│ Job Radar                                   │
└─────────────────────────────────────────────┘

Clicking the title takes you directly to the application page.

Architecture

The workflow uses three main components:

JSearch API (via RapidAPI): Aggregates job listings from Indeed, LinkedIn, Glassdoor, and ZipRecruiter into a single API. Free tier gives you 500 requests per month.

n8n: Self-hosted workflow automation. Handles the scheduling, API calls, data transformation, and Discord posting.

Discord Webhooks: Simple way to post formatted messages to a channel. No bot required.

Here's the data flow:

Schedule Trigger (every 6 hours)
        │
        ▼
   Search Config
   (15 job titles, location, radius)
        │
        ▼
   Split Job Titles
   (process each title separately)
        │
        ▼
   Wait 10 Seconds
   (rate limiting for API)
        │
        ▼
   JSearch API
   (fetch jobs for each title)
        │
        ▼
   Split Jobs
   (separate each job listing)
        │
        ▼
   Filter Valid Jobs
   (remove empty results)
        │
        ▼
   Remove Duplicates
   (dedupe by job_id)
        │
        ▼
   Format Job Data
   (extract title, company, location, salary, url)
        │
        ▼
   Wait 5 Seconds
   (rate limiting for Discord)
        │
        ▼
   Post to Discord
   (batch: 1 message per 3 seconds)

The Job Titles

I'm targeting Cloud/DevOps/IAM roles, so my search includes:

  • Cloud Engineer
  • Cloud Infrastructure Engineer
  • DevOps Engineer
  • IAM Engineer
  • Identity Engineer
  • Platform Engineer
  • Systems Engineer
  • Infrastructure Engineer
  • IT Systems Engineer
  • Security Engineer
  • Automation Engineer
  • Azure Administrator
  • Azure Engineer
  • SRE
  • Site Reliability Engineer

You can customize these to whatever roles you're targeting.

Handling Rate Limits

Both JSearch and Discord have rate limits. If you hit them, you get 429 errors and your workflow fails.

JSearch: Free tier allows 500 requests per month. Each job title counts as one request. With 15 titles running 4 times per day, that's 60 requests per day (1,800 per month). You'll need to either reduce titles, reduce frequency, or upgrade your plan.

I added a 10-second wait between API calls to avoid hitting per-minute limits.

Discord: Webhooks are limited to about 30 messages per minute. With 80+ jobs to post, you'll hit this instantly.

The fix is batching. In the Post to Discord node, I configured:

  • Batch Size: 1
  • Batch Interval: 3000ms (3 seconds)

This posts one job every 3 seconds. A full run with 80 jobs takes about 4 minutes.

The Discord Payload

Discord webhooks accept JSON with an embeds array. Each embed is a formatted card. Here's the structure:

{
  embeds: [{
    title: "Senior DevOps Engineer",
    url: "https://linkedin.com/jobs/view/...",
    color: 36863,
    fields: [
      { name: "🏢 Company", value: "Acme Corp", inline: true },
      { name: "📍 Location", value: "Los Angeles, CA", inline: true },
      { name: "💰 Salary", value: "$150,000 - $180,000", inline: true }
    ],
    footer: { text: "Job Radar" }
  }]
}

The color value is decimal (36863 is a nice blue). The inline: true puts fields side by side.

One gotcha: job descriptions often contain special characters that break JSON. I use JSON.stringify() around the entire payload to escape everything properly.

Setup Overview

The full setup takes about 15 minutes:

  1. RapidAPI: Create account, subscribe to JSearch (free tier)
  2. Discord: Create a webhook in your target channel
  3. n8n: Import the workflow, add credentials, update webhook URL
  4. Customize: Edit job titles and location to match your search
  5. Activate: Toggle the workflow on

I documented the entire process in the GitHub repo with screenshots and troubleshooting tips.

Lessons Learned

WebSockets matter. If you're running n8n behind a reverse proxy (like Nginx Proxy Manager), you need to enable WebSocket support. Otherwise you'll get "Lost connection to the server" errors constantly.

Rate limits are real. Don't assume you can blast 15 API calls and 80 Discord messages instantly. Build in delays from the start.

Deduplication is per-run only. The current workflow removes duplicates within a single run, but if the same job appears tomorrow, it'll post again. Persistent deduplication (with a database) is on the roadmap for v2.

Test incrementally. When debugging, test one node at a time. Click the node, run just that step, inspect the output. Much easier than running the whole workflow and guessing where it failed.

Results

On my first real run, Job Radar found 87 unique jobs within 30 miles of LA. This was an initial test, so the results were mixed.

Relevant hits:

  • Senior SRE with Golang (Jobs via Dice)
  • Cloud Security Engineer (DataAnnotation, East West Bank)
  • DevOps Engineer (City National Bank, TechTalent Solutions)
  • Senior Software Engineer, Azure (Qcells)
  • Deployment Site Reliability Engineer (Anduril Industries, $124K-$231K)

Less relevant:

  • Distinguished Engineer, Chief Architect (Cisco) - too senior
  • Software Engineering Intern (Disney) - wrong level
  • Data Engineer roles - adjacent but not my target

The JSearch API casts a wide net. It searches by job title, but "Cloud Engineer" might return cloud-adjacent roles that don't quite fit. That's expected for a first pass.

The next step is adding keyword filters to score results by relevance (bonus points for Azure, Terraform, Kubernetes, IAM, etc.) and surface the best matches first. For now, having everything in one Discord channel beats checking four job boards manually.

What's Next

Phase 2 will add:

  • Persistent deduplication: Store seen job IDs so the same job never posts twice
  • BD-1 integration: Slash commands in Discord to trigger on-demand searches
  • Keyword scoring: Rank jobs by how many relevant keywords they contain (Azure, Terraform, Kubernetes, etc.)

Get the Code

The entire project is open source:

GitHub: github.com/timanlemvo

The repo includes:

  • Ready-to-import workflow JSON
  • Step-by-step setup guide
  • Customization documentation
  • Troubleshooting tips

If you're navigating a layoff too, feel free to use it. And if you run into issues, open an issue or reach out.

Job Radar is part of the Alliance Fleet, my homelab infrastructure. For more projects like this, check out holocron-labs.tima.dev.