Building an Open-Source AI-Assisted International Job Search Platform

Finding a job in another country is more complicated than searching for a job title.

Candidates often need to understand:

• Whether the company supports visa sponsorship
• Whether the role matches their actual experience
• How to tailor their resume
• How to write a relevant cover letter
• How to prepare for the interview
• How to track applications and follow-ups
• Which opportunities are still active and trustworthy

I’m building an open-source project called JobSearch to bring these activities into one workspace.

GitHub repository:

https://github.com/subraatakumar/job-search

The project is still in its early MVP stage, but the initial Docker setup, authentication, resume import, and profile workflow are working.

The product idea

JobSearch is designed for people applying internationally.

For example, a user in India might want to search for:

• Software engineering roles in Germany
• Companies that may support visa sponsorship
• Remote or relocation-friendly positions
• Jobs matching a specific technology stack
• Roles at a particular seniority level

The long-term workflow is:

Discover jobs
    ↓
Evaluate role and sponsorship fit
    ↓
Prepare a tailored application
    ↓
Practice for the interview
    ↓
Track the application
    ↓
Improve based on outcomes

The goal is not to automatically apply to hundreds of jobs. The goal is to help candidates make better, more informed applications while keeping the user in control.

Current MVP scope

The first version focuses on building a trustworthy foundation.

Currently implemented:

• Next.js and TypeScript application
• Dockerized local development
• PostgreSQL container
• Central authentication using OAuth and PKCE
• Protected dashboard
• Text-based PDF resume upload
• Server-side resume text extraction
• Review-first profile workflow
• Responsive landing page
• Open-source contributor setup script
• Separate local and production-like Docker modes

Planned features include:

• Structured profile fields
• Public job API integrations
• Company career page imports
• User-provided job URL imports
• Visa sponsorship evidence and confidence indicators
• Job matching
• Tailored resumes
• Job-specific cover letters
• Interview questions and practice answers
• Application status tracking
• Reminders and follow-up dates
• OpenAI-compatible AI providers
• Local Ollama support

Why open source?

There are several reasons for making this project open source.

First, job-search data is personal and sensitive. Users should be able to understand where their data goes and how the application works.

Second, different users will want different AI providers. Some may prefer a hosted provider, while others may want to run a local model through Ollama.

Third, job sources vary by country. A community can help add lawful, documented integrations for different regions without tightly coupling the core application to a single provider.

The project is released under the MIT License.

Technical architecture

The current architecture is intentionally simple:

Browser
   ↓
Next.js application
   ↓
PostgreSQL
   ↓
AI provider adapter

The application will eventually include a background worker for scheduled searches:

Scheduler
   ↓
Job source connectors
   ↓
Normalization and deduplication
   ↓
Job database
   ↓
User notifications and matching

The planned technology stack is:

• Next.js
• React
• TypeScript
• PostgreSQL
• Docker Compose
• OAuth with PKCE
• OpenAI-compatible AI provider interface
• Optional local Ollama endpoint
• Background scheduler and worker

Reusing a central authentication service

The project uses an existing central authentication service based on Better Auth.

The authentication service provides:

• Google sign-in
• OAuth authorization-code flow
• PKCE
• Central user identity
• Product-specific OAuth clients
• Separate product-local sessions

The JobSearch application does not directly share authentication cookies or the authentication database.

The flow is:

JobSearch
   ↓
Redirect to central Auth service
   ↓
User signs in
   ↓
Auth redirects back with an authorization code
   ↓
JobSearch exchanges the code using PKCE
   ↓
JobSearch creates its own local session

This keeps the authentication boundary clear and allows other applications to reuse the same identity service without sharing application data.

Running the project locally

The project is designed to be easy to run with Docker.

Requirements:

• Docker Desktop
• curl
• Node.js 22 or newer for non-Docker development

Clone the repository:

git clone https://github.com/subraatakumar/job-search.git
cd job-search

Create the local environment file:

cp .env.example .env

Set a strong session secret in .env, then run:

./re-run-local.sh

The local services are available at:

JobSearch:  http://localhost:3020
Dashboard:  http://localhost:3020/dashboard
Profile:    http://localhost:3020/profile
PostgreSQL: localhost:5433

To stop the services:

docker compose down

The normal shutdown command does not delete the PostgreSQL volume.

Production-like local mode

The project also includes a separate production-like mode:

cp .env.prod.example .env.prod

Configure the production values and run:

./re-run-local.sh prod

This mode uses:

JobSearch:  http://localhost:3021
PostgreSQL: localhost:5434

A Cloudflare Tunnel can route:

jobs.example.com → http://localhost:3021

Local and production-like modes use separate Compose projects and separate database volumes.

Resume import

The first version supports text-based PDF resumes.

The workflow is:

Upload PDF
    ↓
Extract text
    ↓
Create draft profile
    ↓
User reviews the information
    ↓
Confirm the master profile

The application does not yet treat extracted text as confirmed truth.

This is important because resume parsing can produce errors. A parser might misunderstand:

• Dates
• Job titles
• Company names
• Technologies
• Education details
• Links
• Formatting and section boundaries

The user must review the extracted information before it can be used to generate an application.

Scanned or image-only PDF files are not supported in the MVP. OCR is planned for a future version after evaluating:

• Accuracy
• Privacy
• Processing cost
• Multilingual resume support
• Layout complexity

AI provider flexibility

The project is designed to support OpenAI-compatible endpoints.

The long-term goal is to let users configure:

• Hosted AI providers
• OpenAI-compatible APIs
• Local Ollama endpoints
• Other compatible model servers

This is important because users have different requirements around:

• Privacy
• Cost
• Performance
• Model quality
• Data residency
• Offline usage

The application should never silently send a user's resume or profile data to an AI provider. Provider configuration and consent must be explicit.

Privacy and safety decisions

The project handles sensitive information, including:

• Resumes
• Contact details
• Employment history
• Education
• Application notes
• Interview preparation
• Job-search preferences

Important design principles include:

• Never commit secrets or personal data
• Do not store API keys in browser code
• Do not log access tokens or session cookies
• Do not fabricate user qualifications
• Keep generated documents linked to their source job
• Require user review before application submission
• Provide data export and deletion capabilities
• Preserve source evidence for job information where possible

The project will not implement:

• Cookie extraction
• CAPTCHA bypassing
• Credential theft
• Unauthorized scraping
• Automated applications against platforms that prohibit automation

Job sources should use official APIs, permitted feeds, company career pages, user-provided URLs, or other lawful methods.

Current UI

The landing page explains the product workflow and includes:

• International job-search positioning
• Resume and profile setup
• AI-assisted application preparation
• Interview preparation
• Application tracking
• Local and hosted AI provider support
• Open-source project access

The profile page includes a drag-and-drop PDF upload area and extracted resume preview.

The UI is being polished screen by screen instead of waiting for a large redesign at the end. This allows the product to remain usable while the underlying features are developed.

What I’m looking for

I would especially welcome feedback on:

1. Which job sources should be supported first?
2. How should visa sponsorship evidence be displayed?
3. What profile information is essential for international job matching?
4. What should the first job-search dashboard include?
5. Which AI providers should be supported first?
6. Should the app remain local-first, or become a hosted multi-user platform?
7. What would make this useful for your own job search?

Contributing

Contributions are welcome.

Before contributing, please read:

• CONTRIBUTING.md
• SECURITY.md
• CODE_OF_CONDUCT.md

The project is still early, so useful contributions may include:

• UI improvements
• Accessibility fixes
• Resume parsing improvements
• Job-source connectors
• Database design
• AI provider adapters
• Testing
• Documentation
• Privacy and security reviews
• Product feedback

Please keep pull requests focused and include testing or verification steps.

Final thoughts

International job searching is often fragmented across job boards, spreadsheets, documents, notes, and interview preparation tools.

JobSearch is an attempt to bring those activities together while keeping the user in control of their data and AI provider.

The project is early, but the foundation is now in place:

• It runs locally with Docker
• Authentication works
• The dashboard is protected
• Resume text extraction works
• The project is publicly documented
• The repository is open source

If this problem interests you, I would love feedback, ideas, issues, and contributions.

GitHub:

https://github.com/subraatakumar/job-search