Jobsy

Inspiration

Job hunting is repetitive, time-consuming, and honestly, pretty draining. You have to search through hundreds of listings, figure out which ones match your skills, tailor your resume and cover letter, answer application questions, and keep track of everything you've applied to.

I wanted to make this process easier, so I built Jobsy, an AI-powered job application assistant that helps automate the tedious parts of job hunting while keeping the user in control.

The idea was simple: spend less time on repetitive tasks and more time finding the right opportunities.

What I Built

Jobsy helps manage the entire job application process, from discovering opportunities to tracking applications.

Here's what it can do:

1. Discover and collect relevant job opportunities.
2. Match jobs against a user's resume, skills, education, and experience.
3. Explain why a particular job might be a good fit.
4. Generate personalized cover letters and application responses.
5. Validate generated content to catch unsupported claims and potential hallucinations.
6. Queue applications for review and processing.
7. Track application statuses, logs, and outcomes through a dashboard.

Instead of relying on a single AI prompt to handle everything, I designed Jobsy around an agent-based workflow where each stage has its own responsibility. This makes it easier to monitor what's happening, identify failures, and improve individual parts of the system.

How I Built It

I built Jobsy using a TypeScript-based full-stack architecture. The backend handles users, resumes, jobs, matches, applications, agent runs, and processing logs.

Since tasks like job discovery and AI content generation can take time, I also incorporated background workers to handle these operations without blocking the main application.

The core workflow looks something like this:

Job Discovery → Job Matching → Content Personalization → Validation → Application Review

I used AI agents for tasks such as understanding job descriptions, comparing requirements against a user's experience, generating personalized application materials, retrieving relevant information from the user's profile, and identifying potentially unsupported claims.

I also wanted to keep AI generation separate from validation and execution. Generated content goes through additional checks, and users can review it before important actions are taken.

What I Learned

One of my biggest takeaways was that building a useful AI product involves much more than just connecting an LLM to an application. The real challenge is making the entire system reliable.

While building Jobsy, I learned how to:

• Design multi-step AI workflows with explicit state transitions.
• Combine deterministic logic with LLM-based reasoning.
• Ground generated content in a user's actual experience instead of letting the model make things up.
• Use background queues for long-running tasks.
• Track agent activity and failures through structured logs.
• Add safeguards around automated actions.
• Separate content generation, validation, and execution into distinct stages.
• Make AI recommendations more transparent and easier to understand.

I also learned to treat AI-generated content as a draft rather than something I can automatically trust. Even when an answer sounds convincing, it still needs to be checked against actual evidence.

Challenges I Faced

Reliable AI Output

LLMs can generate convincing but inaccurate information. That's particularly risky when generating resumes, cover letters, or answers to application questions.

To address this, I added a process for retrieving relevant evidence from the user's profile and validating generated content against it. The goal was to catch unsupported claims before they made it into an application.

Workflow State Management

Jobsy has several asynchronous stages, from discovering jobs to generating content and processing applications.

Keeping everything in the correct state was challenging. An application shouldn't be marked as successful just because an earlier stage completed successfully.

I had to think carefully about state transitions, error handling, and how to track the outcome of each stage.

Balancing Automation with User Control

Fully automating job applications sounds great until the system submits an incorrect application on your behalf.

I didn't want to build something that blindly submits whatever an LLM generates. Instead, I designed Jobsy around configurable policies, review queues, and controlled execution so users can inspect generated content before important actions happen.

Matching Quality

Matching jobs based on keywords alone isn't enough. Different companies can describe the same skill differently, and job descriptions often contain requirements that aren't explicitly stated.

I wanted Jobsy to go beyond simple keyword matching and consider the actual relevance of a candidate's skills and experience. Making these matches accurate and explainable remains an area I'd like to improve further.

System Complexity

Jobsy brings together a web application, AI workflows, background workers, persistent storage, queues, and external services.

Getting all these components to work together reliably required clear separation of responsibilities, structured logging, and defensive error handling.

This was a good reminder that even if individual components work perfectly on their own, the overall system can still fail when they interact.

What's Next?

There's still plenty I'd like to improve in Jobsy:

• More reliable duplicate application detection and prevention.
• Stronger

Built With

• algorithms
• fastapi
• llm
• python
• rag