freehire job search engine: open source in Go

freehire job search engine, open source in Go: MIT licence, installation from the README, limits and how to monitor the API and its scheduled jobs.
freehire moteur recherche d'emploi open source en Go

The freehire job search engine is the strelov1/freehire repository: an open source search engine for IT job postings, written in Go, which claims to aggregate more than 3.3 million open postings pulled directly from companies’ careers pages. It has about 2,600 stars and 262 forks as of the check on 22 October 2026, under the MIT licence. The project also exists as a hosted service (freehire.me), but its interest for this blog is different: the whole chain (crawling, deduplication, indexing, API) is in the repository and can be self-hosted.

That makes it a good operations subject: a web API, a PostgreSQL database, a Meilisearch engine, Redis and a series of scheduled jobs. This guide follows the README and the repository code.

A note on honesty: span.observer has not installed or run freehire. The commands come from the README; the posting counts are those announced by the project, not verified by us.

The freehire job search engine: what the repository says

  • Licence and language: MIT; Go server (Fiber framework), SvelteKit front end.
  • Figures checked on 22 October 2026 on the repository page: about 2,600 stars (the page only shows “2.6k”), 262 forks, no published release.
  • What the README claims: a snapshot dated 20 October 2026 of 3,371,563 unique open postings, 477,323 companies and 320 sources, including 117 applicant tracking system (ATS) platforms such as Workday, Greenhouse or Lever, plus 97 Telegram channels. These are the project’s figures.
  • Principle: each posting is normalised into a single schema and deduplicated; filters (region, work mode, seniority, skills, salary) come from hand-curated dictionaries, not from a model’s guesses, according to the README.

Beyond search, the README describes a “candidate” layer: CV builder, application tracking, AI assistant, MCP server and browser extension. Several of these features need an OpenAI-compatible LLM endpoint that you configure yourself (LLM_BASE_URL, LLM_API_KEY, LLM_MODEL in the example file).

A tour of the interface

The README screenshot shows the search page: a search bar, the total number of postings, filters on the left (region, work mode, specialisation, seniority) and the list of postings on the right, each with the company, location, level and age of the ad. The company names visible are those of the repository’s example, and each posting links, according to the README, to the company’s own page.

Screenshot from the freehire README: job search page with a search bar, region, work mode, specialisation and seniority filters on the left, and a list of job postings on the right
Source : github.com

Step-by-step installation

The README quick start assumes Docker; it starts the whole stack (API, front end, PostgreSQL, Meilisearch, Redis, S3-compatible storage).

  1. Clone the repository and move into the folder.
  2. Start the stack, then test:
    make up
    curl localhost:8080/health
    curl localhost:8080/api/v1/jobs
  3. If port 8080 is taken, pick another host port:
    HIRE_HOST_PORT=8090 make up
Extract from the freehire README: commands make up, curl localhost:8080/health, curl localhost:8080/api/v1/jobs and HIRE_HOST_PORT=8090 make up

Migrations are applied automatically when the PostgreSQL volume is first initialised; if you change a migration, recreate the volume with docker compose down -v && make up or use make migrate. For development, the README suggests docker compose up -d db then make run, with a .env file copied from .env.example. The JWT_SECRET variable is required for the server to start; the example file carries a development value that must be replaced by a strong random secret outside a local machine.

The server only serves the API. Crawling, enrichment, indexing and notifications are run-once workers meant to be scheduled (cron): for example go run ./cmd/ingest greenhouse to crawl one provider, go run ./cmd/search-drain to run every one to two minutes to push writes into the index, or go run ./cmd/reindex to rebuild the Meilisearch index. Each worker requires DATABASE_URL and exits non-zero on failure: that is exactly what your scheduler should watch.

Limits and open points

  • Young project: no published release; a very active repository (the latest commit we read is dated the day of writing) whose configuration surface may change quickly. Pin a commit.
  • Collected data: the tool crawls public careers pages and third-party feeds. The terms of use of the source sites, personal data protection and rate limits remain your responsibility if you self-host.
  • Unverified figures: the posting volume and freshness are announced by the project.
  • AI features: they depend on an LLM you provide, with costs and data going to the chosen provider. See choosing an LLM by operational criteria.
  • Stack size: at least five services and scheduled jobs, far from a single binary.

Monitoring freehire in production

The README names the project’s observability stack: Langfuse to trace LLM calls, Prometheus (through node_exporter’s textfile collector) and Grafana for ingestion and LLM metrics. In the code, the configuration reads a METRICS_PORT variable: if set, the server exposes /metrics on a dedicated port rather than on the API port, so that an internal-only firewall rule does not let the rest of the API through (comment in config.go). The server uses the Prometheus client library for this.

For your own monitoring, whether on Dynatrace SaaS or Dynatrace Managed:

The repository does not announce an OpenTelemetry trace export; the OpenTelemetry dependencies present in go.mod are marked “indirect”. Do not count on ready-made traces.

How to check that it works

  1. curl localhost:8080/health answers; curl localhost:8080/api/v1/jobs returns an object with data and meta (format described in the README), possibly empty until something is crawled.
  2. After a first cmd/ingest then cmd/search-drain, postings appear in the search.
  3. If METRICS_PORT is set, /metrics answers on that port.

Best practices

  • Replace JWT_SECRET and never leave the metrics port open to the Internet.
  • Schedule the jobs with an orchestrator that logs exit code and duration.
  • Back up PostgreSQL: it is the system of record, the index can be rebuilt.
  • For other self-hosted building blocks, see the self-hosted open source AI stack; for a Postgres platform in the same spirit, see Supabase.

Frequently asked questions

Should I self-host or use freehire.me?

The hosted site is enough to search for jobs. Self-hosting makes sense to use the data or the API, at the price of a stack to maintain.

Do I need an LLM?

Not for search: the features that need one stay disabled until the LLM_* variables are set, according to the README and the feature documentation.

Can I add a company?

Yes: the README says adding a company is one row in the “boards” catalogue (company, provider, board id), through the form on the site or the cmd/add-board command, and asks you to open an issue first for a new platform.

Conclusion

freehire is a complete, open job search engine, interesting to read as an architecture: API, run-once workers, separate index and metrics. What remains is to check its figures and your obligations on the data collected. Sources: the strelov1/freehire repository.

span.observer is an independent community blog, not affiliated with Dynatrace LLC or the projects mentioned. Trademarks belong to their owners. Tools change quickly: check commands and options in their official documentation.

Total
0
Shares
Leave a Reply

Your email address will not be published. Required fields are marked *

Previous Post
Kronos modèle fondation pour les marchés financiers

Kronos financial markets foundation model explained

Next Post
REA ingénierie inverse par agents IA via MCP

REA reverse engineering with AI agents over MCP

Related Posts