JobSeek: The Secret Weapon Top Developers Use to Beat LinkedIn

What if I told you that your dream job was posted six hours ago—and you haven't seen it because LinkedIn's algorithm decided you weren't worthy?

Here's the brutal truth: the best roles never make it to your feed. By the time a posting bubbles through LinkedIn's engagement-optimized sludge, through recruiter reposts, through Indeed's duplicate-mangled database, the hiring manager already has twenty qualified candidates in their inbox. The early bird gets the worm, but LinkedIn keeps you sleeping in.

What if you could monitor 4,400+ company career pages directly? Not through third-party aggregators. Not through recruiter middlemen. Straight from the source. Roles landing in your dashboard within hours of posting, in clean, canonical form, with powerful faceted search that actually understands seniority, tech stack, and salary bands.

That weapon exists. It's called JobSeek, and it's about to change how you hunt for work forever.

Built by the Colophon Group in Switzerland, this open-source job aggregator is what happens when developers get fed up with broken job platforms and build something genuinely better. MIT-licensed. Self-hostable. Or just use jseek.co and start winning immediately.

What Is JobSeek?

JobSeek is an open-source job aggregation platform that monitors company career pages directly—currently tracking 4,400+ vetted companies including Stripe, Anthropic, OpenAI, Figma, Vercel, Datadog, Mistral, Hugging Face, Linear, Notion, and thousands more.

The project emerged from a simple, infuriating observation: job discovery is fundamentally broken. Existing platforms optimize for engagement, not accuracy. They show you what's already popular, not what's newly available. They duplicate single roles into dozens of confusing entries. They delay postings by days. And they trap you in algorithmic feeds designed to keep you scrolling, not applying.

Colophon Group, a small Swiss team, decided to solve this at the infrastructure level. Rather than scraping job boards that scrape other job boards, JobSeek goes straight to employer career pages. Greenhouse, Lever, Workday, custom-built portals—whatever the company uses, JobSeek monitors it directly.

The result? Canonical job data: one entry per role, surfaced within hours, with no third-party repost pollution. The project has gained significant traction in developer communities precisely because it solves a problem everyone feels but few articulate: information asymmetry in the job market favors employers, not candidates.

With dual licensing—MIT for code, CC BY-NC 4.0 for job data—JobSeek balances openness with sustainability. The hosted version at jseek.co offers free exploration and application tracking, with Pro features for power users. But the real revolution? You can run the entire stack yourself.

Key Features That Crush the Competition

JobSeek isn't a marginally better job board. It's a fundamentally different architecture for job discovery. Here's what makes it technically superior:

Direct Source Monitoring Instead of scraping aggregated job boards, JobSeek maintains 40+ specialized monitors and scrapers targeting specific ATS platforms (Greenhouse, Lever, Workday) and custom career page implementations. This eliminates the duplication cascade that plagues traditional aggregators.

Sub-Hour Latency The Redis-backed claim queue with atomic reservation, requeue, and reschedule logic ensures crawlers efficiently distribute work. New postings typically surface within hours of employer publication—not days.

Typesense-Powered Faceted Search Real faceted search by seniority level, tech stack, geographic locale, salary range, and posting language. Not keyword matching. Not location radius guessing. Structured, filterable data that respects how developers actually think about opportunities.

Canonical Data Model One role, one entry. The CSV-based company registry (data/companies.csv) and board configuration (data/boards.csv) create a single source of truth that prevents the 1-to-N duplication explosion common on LinkedIn and Indeed.

Full Application Lifecycle Tracking Built-in CRM for your job search: saved → applied → interviewing → offered/rejected with interview logs and statistical tracking. Free. No account required for basic exploration.

Agent-Driven Company Onboarding The ws CLI tool orchestrates coding agents (Claude Code, Cursor) to add new companies in ~5 minutes. The agent selects optimal monitor/scraper combinations from 40 available options—getting this wrong silently drops postings, which is why human-guided automation matters.

Production-Grade Internationalization Path-prefix i18n (en/de/fr/it) built on Lingui, reflecting the Swiss team's commitment to multilingual markets that most US-centric platforms ignore.

Use Cases: Where JobSeek Absolutely Dominates

The Passive Candidate Who Refuses to Miss Opportunities

You're not desperate. You're strategically monitoring. You want to know when Stripe opens that Staff Engineer role, when Anthropic posts a new Research Engineer position, when your target company finally lists something matching your exact specialization. JobSeek's watchlists with email alerts (Pro) turn passive monitoring into active advantage.

The International Developer Sick of Geo-Locked Platforms

LinkedIn's search assumes you're searching where you live. JobSeek's locale faceting and multilingual posting detection surface Swiss fintech roles, German automotive positions, French AI labs—without platform-imposed geographic bias. The i18n architecture isn't cosmetic; it's structural.

The Career Switcher Needing Signal, Not Noise

Transitioning from backend to ML infrastructure? Traditional platforms drown you in irrelevant "full stack^{↗ Bright Coding Blog}" spam. JobSeek's tech stack faceting lets you filter for specific technologies, company-stage signals, and role types that match your trajectory—not your history.

The Team Building Internal Talent Intelligence

Recruiting firms, VC talent partners, and career coaches need clean, timely, structured data. JobSeek's self-hosted option with MIT-licensed code lets you build proprietary intelligence layers on top of canonical job data—without platform risk or API dependency.

The Open Source Advocate Refusing Vendor Lock-in

You don't trust algorithms you can't inspect. JobSeek's entire pipeline—from Playwright-based crawling through Postgres CDC export to Typesense indexing—is auditable, modifiable, and yours. No black-box ranking. No engagement optimization. Just data.

Step-by-Step Installation & Setup Guide

Ready to own your job search infrastructure? Here's how to run JobSeek yourself.

Prerequisites

Python^{↗ Bright Coding Blog} 3.12+ with uv for the crawler
Node 20+ with pnpm for the web app
Postgres, Redis, and Typesense instances
git and authenticated gh CLI

Clone the Repository

# Get the complete codebase
git clone https://github.com/colophon-group/jobseek
cd jobseek

Crawler Setup (Python Pipeline)

# Navigate to crawler application
cd apps/crawler

# Install dependencies using uv (ultrafast Python package manager)
uv sync

# Configure environment variables
cp .env.example .env.local
# Edit .env.local with your credentials:
# DATABASE_URL=postgresql^{↗ Bright Coding Blog}://...
# REDIS_URL=redis://...
# TYPESENSE_API_KEY=...
# TYPESENSE_HOST=...
# TYPESENSE_PORT=...

# Initial sync: populate database from company registry
uv run crawler sync    # Reads CSV → Postgres + Redis + Typesense

# Start continuous monitoring worker
uv run crawler run     # Background process that claims and processes jobs

The sync command seeds your infrastructure from data/companies.csv and data/boards.csv—the project's single sources of truth. The run command starts the asyncio-based worker that continuously monitors career pages using Playwright fallbacks when APIs aren't available.

Web Application Setup (Next.js^{↗ Bright Coding Blog} Frontend)

# Navigate to web application
cd ../web

# Install Node dependencies
pnpm install

# Apply database migrations (Drizzle ORM)
pnpm db:migrate

# Start development server
pnpm dev              # Available at http://localhost:3000

The web stack uses Next.js 16 with App Router, Drizzle ORM for type-safe database operations, Better Auth for authentication, and Lingui for internationalization. The path-prefix i18n structure (app/[lang]/...) serves content in English, German, French, and Italian.

Production Considerations

For production deployment, consult:

Architecture deep-dive: AGENTS.md
Typesense configuration: docs/11-typesense.md
Operational routines: error review and daily labelling

REAL Code Examples from the Repository

Let's examine actual implementation patterns from JobSeek's codebase. These aren't toy examples—they're production code handling thousands of companies.

Example 1: Agent-Driven Company Onboarding

The ws tool is designed for coding agents, not direct human use. Here's how your agent installs and invokes it:

# Install the workspace orchestrator via PyPI
pip install jobseek-crawler-setup

Once installed, your coding agent (Claude Code, Cursor, etc.) runs:

# Replace <NUMBER> with actual GitHub issue number
ws task --issue <NUMBER>

This single command triggers a guided workflow that:

Fetches the issue details from GitHub
Identifies the target company's career page URL
Tests available monitors against the page structure
Selects optimal scraper from 40 implementations
Validates that postings are correctly extracted
Generates a pull request with the new configuration

Why this architecture matters: Choosing the wrong monitor-scraper combination silently drops job postings. The ws tool encodes Colophon Group's operational knowledge into an auditable workflow. Manual configuration is tedious and error-prone; agent-guided selection leverages pattern recognition at scale.

The agent environment requires git, authenticated gh CLI, Python 3.12+, and web access—standard tooling that doesn't require special infrastructure.

Example 2: Repository Structure and Data Flow

Understanding JobSeek's organization reveals its architectural sophistication:

apps/crawler/          # Python pipeline (asyncio, Playwright fallback)
  src/core/monitors/   # Monitor types — Greenhouse, Lever, Workday, …
  src/core/scrapers/   # Scrapers — JSON-LD, DOM, sitemap, vendor-specific
  src/redis_queue.py   # Claim queue with atomic reservation, requeue, reschedule
  src/exporter.py      # CDC: Postgres → Supabase + Typesense
  src/labeller/        # Daily labelling pipeline (HuggingFace upload)
  src/workspace/       # `ws` — agent orchestrator for company onboarding
  data/companies.csv   # Source of truth — every tracked company is one row
  data/boards.csv      # One row per board (monitor + scraper config)

apps/web/              # Next.js 16 + Drizzle + Lingui + Better Auth
  app/[lang]/...       # Path-prefix i18n (en / de / fr / it)
  src/db/schema.ts     # Drizzle schema — Postgres + Supabase mirror

docs/                  # Architecture and operational routines
scripts/               # Typesense setup, backfill, IndexNow notifications

Key architectural decisions exposed:

Separation of concerns: Crawler (data acquisition) and web (presentation) are independent deployables
CSV-based configuration: Human-readable, git-diffable, reviewable company registry
Redis claim queue: Prevents duplicate work in distributed crawler deployments
CDC exporter: Change Data Capture pattern keeps search index synchronized without tight coupling
Daily labelling: Continuous quality improvement through structured data sampling

Example 3: Development Server Launch

The complete local development workflow demonstrates the project's modern tooling choices:

# Web app (Node 20+, pnpm)
cd ../web
pnpm install
pnpm db:migrate
pnpm dev                        # http://localhost:3000

Technical details worth noting:

pnpm for disk-space-efficient, deterministic dependency management
db:migrate applies Drizzle migrations, maintaining schema evolution history
Development server runs on standard port 3000 with hot reloading
The ../web path assumes you're in apps/crawler context—typical monorepo navigation

This isn't legacy infrastructure. Next.js 16, Drizzle ORM (not Prisma's black-box migrations), Better Auth (modern, framework-agnostic authentication)—these are deliberate choices reflecting current best practices, not accumulated technical debt.

Advanced Usage & Best Practices

Optimize Your Typesense Configuration The faceted search power depends on proper collection schemas. Review docs/11-typesense.md for scoped API keys, collection design, and deployment patterns. Poor schema design degrades filter performance significantly.

Monitor Your Crawler Health Implement the error review routine weekly. Silent failures in scrapers are the primary data quality risk—proactive monitoring catches monitor-scraper mismatches before they cause data gaps.

Leverage the Labelling Pipeline The daily sampling routine (src/labeller/) uploads to HuggingFace for quality analysis. Run this to continuously improve classification accuracy for seniority, stack, and locale detection.

Customize for Your Market The CSV-based company registry makes geographic or industry specialization trivial. Fork, filter companies.csv to your target market, and deploy a focused instance.

Use IndexNow for SEO The scripts/ directory includes IndexNow notification automation—critical if you're running a public instance and want search engines indexing new postings rapidly.

Comparison with Alternatives

Dimension	JobSeek	LinkedIn / Indeed	Roll-your-own (JobSpy, JobFunnel)
Source	Direct from employer career pages	Aggregated from job boards	Whatever you wire up
Postings per role	One canonical entry	1–N copies	Depends
Coverage	4,400+ vetted companies	Millions, mostly duplicates	Bring your own
Latency from posting	Typically hours	Days	Your schedule
Search	Typesense, faceted (seniority, stack, locale, salary)	Keyword + location	None bundled
Self-host	Yes — one repo, MIT	Not possible	DIY
License	MIT code, CC BY-NC 4.0 data	Closed	Per-project
i18n	Built-in (en/de/fr/it)	Limited	None
Application tracking	Built-in CRM	Basic saved jobs	None
Agent onboarding	Automated via `ws`	N/A	N/A

The verdict: LinkedIn optimizes for engagement time. JobSeek optimizes for information velocity. Roll-your-own solutions demand significant integration effort for search, tracking, and UI that JobSeek provides out-of-the-box.

FAQ

Is JobSeek free to use? Yes. The hosted version at jseek.co offers free exploration and application tracking. Pro features ($10/month) add unlimited watchlists with email alerts. Self-hosting is completely free under MIT license.

Can I add my current employer or target company? Absolutely. Open a company request issue or use the ws agent workflow if you have coding agent access. Most requests resolve quickly.

How does JobSeek handle sites that block scrapers? The crawler uses asyncio with Playwright fallback for JavaScript^{↗ Bright Coding Blog}-rendered pages and anti-bot challenges. The 40+ scraper implementations include specialized handlers for major ATS platforms.

Is the job data really fresher than LinkedIn? Direct monitoring eliminates aggregation delay. While LinkedIn depends on employer posting, recruiter republication, and algorithmic surfacing, JobSeek's typical latency is hours versus days.

Can I use JobSeek data commercially? Code: yes, MIT license permits any use. Job-posting data: CC BY-NC 4.0 requires attribution and restricts commercial use. Contact business@colophon-group.org for commercial licensing.

What tech skills do I need to self-host? Python 3.12+, Node 20+, and comfort with Postgres/Redis/Typesense administration. The documentation is comprehensive; basic DevOps knowledge suffices.

How does the application tracker compare to dedicated tools? It's intentionally lightweight: saved → applied → interviewing → offered/rejected with interview logs. For most job seekers, this replaces spreadsheet chaos without Hunter.io complexity.

Conclusion

The job market is information warfare, and you've been fighting with dull tools. LinkedIn's algorithm doesn't serve you—it serves engagement metrics. Indeed's duplication doesn't help you—it confuses you. Traditional aggregators are middlemen extracting rent from your career.

JobSeek is different. It's infrastructure for serious professionals who refuse to let platform limitations dictate opportunity access. Whether you use the hosted jseek.co experience or deploy the entire MIT-licensed stack yourself, you're gaining information asymmetry in your favor for the first time.

The Swiss team at Colophon Group has built something genuinely rare: open-source software that competes with closed platforms on features while crushing them on philosophy. Canonical data. Sub-hour latency. Real faceted search. Full transparency. No algorithmic gatekeeping.

Your next role was posted somewhere in the last 24 hours. The question is whether you'll find it before the competition does.

Stop scrolling. Start seeking.

👉 Explore jseek.co now or star the repository and self-host your own instance. The code is waiting. Your future employer just posted something. Go find it.

Built in Switzerland by Colophon Group. Issues and PRs welcome at github.com/colophon-group/jobseek.