A Rails-based job application tracker that helps job seekers understand their complete application lifecycle and identify where they're getting stuck in the hiring process.

Current job search tracking tools (spreadsheets, basic apps) don't capture the full application lifecycle, especially code assessments and rejection stages. Job seekers need better visibility into WHERE in the process they're getting rejected to improve their strategy.

JobTrail provides:

• Full lifecycle tracking - Track applications from submission through screening, assessment, interviewing, offer, or rejection
• Rejection stage analytics - Capture exactly which stage rejections happen at
• Conversion insights - Understand your conversion rates by stage
• Pattern recognition - Identify trends to improve your job search approach

• Applied - Submitted application
• Screening - Recruiter/phone screen scheduled
• Assessment - Code challenge/take-home assigned
• Interviewing - Technical/on-site interviews
• Offer - Received offer
• Rejected - No at any stage (tracks WHICH stage)
• Closed - Withdrew or declined

• Total applications
• Conversion rates by stage
• Average time in each stage
• Success rate trends
• Rejection pattern analysis

• CRUD operations for job applications
• Status timeline tracking
• Search and filter by company, status, date range
• CSV import/export

• Backend: Ruby on Rails 8.x
• Frontend: Hotwire (Turbo + Stimulus)
• Database: PostgreSQL
• Styling: Tailwind CSS
• Deployment: Docker + Kamal/Thruster

• Ruby 3.3+
• Rails 8.x
• PostgreSQL
• Docker & Docker Compose (for containerized development)

1. Clone the repository:

   git clone https://github.com/emckenna/jobtrail.git
   cd jobtrail

2. Build and start the containers:

   docker-compose up --build

   This will:

   • Start PostgreSQL database
   • Install dependencies
   • Start the Rails server with Tailwind CSS compilation
   • The app will be available at http://localhost:3000

3. In a separate terminal, create and setup the database:

   docker-compose run web rails db:create db:migrate

4. (Optional) Load seed data:

   docker-compose run web rails db:seed

1. Install dependencies:

   bundle install

2. Setup database:

   rails db:create db:migrate

3. Start the server:

   rails server

4. Visit http://localhost:3000

• Company name (string, required)
• Job title (string, required)
• Application link (string)
• Application date (date, required)
• Current status (enum, required)
• Status updated date (datetime)
• Rejected at stage (enum, nullable)
• Salary range min/max (integer)
• Contact name (string)
• Contact email (string)
• Notes (text)
• Follow-up date (date)

A sample CSV file is provided at sample-data.csv showing the expected format.

To import your own job applications data:

1. Create a CSV file with the following columns:

   • Company Name, Job Title, Application Link, Application Date, Status, Contact Name, Contact Email, Follow-Up Date, Notes

2. Place your CSV file at claude_artifacts/Job-Search.csv

3. Run the import task:

   # With Docker
   docker-compose run web rails data:import_applications
   
   # Without Docker
   rails data:import_applications

Supported Status values: Applied, Screening, Rejected, Closed, Withdrawn

# With Docker
docker-compose run web rails test

# Without Docker
rails test

The application includes production-ready Docker configuration and deployment tools:

The app includes Kamal for deployment to any server. See the Kamal documentation for setup instructions.

• AWS ECS/Fargate - Use the production Dockerfile
• DigitalOcean App Platform - Docker-based deployment
• Heroku - Requires buildpack configuration (not included by default)
• Any VPS - Manual Docker deployment or Kamal

The production Dockerfile uses Thruster for HTTP caching and compression, serving on port 80.

This is an active development project being used for real-world job tracking. The MVP focuses on core tracking and analytics features.

This is a personal project, but suggestions and feedback are welcome via issues.

MIT

Built out of necessity during a job search to solve a real problem - tracking where applications stall in the hiring funnel.