Job Ready: Tailor Your CV Without Inventing Your Experience

Job Ready: An Honest Next Step for Your Next Role

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

I built Job Ready, an app that checks your existing CV against a specific job and helps you take the next step without inventing experience.

Upload a PDF or DOCX, paste the role title and job description, and get one of two results:

• Ready to send: a fact-checked CV rewrite, a fit report, and a downloadable PDF.
• Gaps to close: a practice plan, with missing required skills listed before missing preferred skills.

But a missing skill on a CV does not always mean missing experience. Sometimes you have done the work and simply left it out.

Job Ready addresses that through a private “Update my CV” conversation. From a flagged major or minor gap, you can explain what you actually did. Gemma proposes changes supported by your statements, you review and confirm their accuracy, and the application updates your CV and reassesses that role.

That creates a useful loop: assess the CV, surface missing evidence, clarify real experience, and check again. If you still have a gap, the practice plan gives you something concrete to work on.

The intended customers are job seekers preparing several applications and career coaches helping clients describe their experience clearly. My business hypothesis is that they would pay for less repetitive editing, evidence-backed CV updates, and focused preparation for each role. Paying-customer demand still needs validation.

Demo

Try Job Ready.

Create an account, upload a text-based PDF or DOCX CV, and paste a job description.

Here is one example of the clarification flow:

1. The assessment flags pytest as a missing preferred skill—a minor gap.
2. The person selects “Have this experience? Update your CV.”
3. In the private conversation, they write: “I have worked with pytest.”
4. Gemma proposes adding pytest to the skills list by asking some questions.
5. The person reviews the proposed edit and confirms that it accurately describes their experience.
6. “Apply & reassess” saves the change and runs the role check again.

The same flow is available for missing required skills, which are marked as major gaps. An update does not automatically make someone ready: the application calculates the result again using its existing rules.

The person can also choose to refresh their shared profile. Other saved role checks retain their previous assessments.

Code

The code is available on GitHub:

tusharv / green-grass

Your next role. An honest next step.

Job Ready

Job Ready, at jobready.tech, checks one CV against one job. A signed-in person uploads a text PDF or DOCX, pastes a role, and gets one of two honest results: a fact-checked CV they can download as a PDF, or a practice plan for required skills the work history does not show.

The model extracts structure and rewrites wording. It does not decide whether the CV is ready, and it does not invent employers, titles, dates, degrees, tools, or numbers. Suitability is scored in code.

What you get

1. Upload a text PDF or DOCX. The original file is discarded. The server keeps the extracted text and a structured profile.
2. Paste a role title and job description.
3. The server pulls required and preferred skills from the posting, then scores the saved profile.
4. Ready to send when the score clears the bar: a rewritten CV, the fit report, and a…

View on GitHub

The main pieces are:

• app/services/pipeline.py — coordinates extraction, assessment, and the resulting CV or gap plan.
• app/services/fit.py — validates supporting quotes and calculates suitability.
• app/services/facts.py — checks generated CVs and gap plans before saving.
• app/services/cv_chat.py — restricts proposed CV edits and grounds them in the person’s statements.
• app/cv_chat_routes.py — manages private conversations, confirmation, and applying updates.

How I Built It

Job Ready uses Gemma through Ollama, with gemma4:31b as the configured default model.

Gemma handles the language tasks throughout the workflow:

• Extracting a structured profile from CV text.
• Extracting required and preferred skills from a job posting.
• Identifying work-history quotes that support a skill.
• Rewriting existing experience for the target role.
• Creating practice plans for missing skills.
• Turning user-provided clarification into proposed CV edits.

Keeping assessment grounded

The suitability decision belongs to Python code.

The application combines required-skill coverage and years of experience using a fixed formula. Work-history quotes must match the saved source text. Skills-list matches are checked in code, and preferred skills do not block suitability.

Gemma helps interpret and express information, while the application controls which evidence is accepted and which result is available.

Generated CVs also pass through fact checks. Protected facts such as employers, titles, and dates must remain intact. Contact details and education come from the saved profile. Failed checks are not saved.

Clarifying experience before changing the CV

The private chat handles an important distinction: “not evidenced in your CV” can mean either missing experience or missing information.

Gemma proposes edits from the conversation, and server-side checks require supporting text from the person’s messages. Added skills must be explicitly supported. Work-history changes require the employer to be named, and new numbers need source support.

For example, “I have worked with pytest” can support adding pytest to the skills list. It does not establish which employer used it, how long the person used it, or what measurable results they achieved.

Proposals remain unsaved until the person reviews them, confirms their accuracy, and selects “Apply & reassess.” Applying a proposal updates the source CV and current assessment together, with an optional update to the shared profile.

The chat can edit the summary, skills, and existing work bullets. It cannot change identity fields, education, or total years of experience. The original extracted upload text remains unchanged.

These checks validate that a proposed edit is supported by the person’s statements. They do not independently verify that the experience happened.

The application stack

The interface uses Svelte 5, with FastAPI and Pydantic handling the backend and structured data.

pypdf and python-docx extract CV text. WeasyPrint generates PDFs for ready results. The original uploaded file is discarded after extraction; extracted text and a structured profile are retained.

The app uses SQLite locally and PostgreSQL on Render. FastAPI serves the built frontend, keeping deployment within one application.

Automated API tests use scripted model responses so the application’s rules can be checked without calling a live model.

Why Does Open Innovation Matter?

For Job Ready, open innovation means having room to improve the model behind a very specific workflow.

CV extraction, evidence screening, and conversational edits have different failure modes. A model might rewrite a sentence well but infer too much from a short statement about someone’s experience. Open weights create the opportunity to evaluate alternative models and explore targeted tuning for those tasks.

The model and host are configurable, while scoring, evidence checks, and confirmation remain application rules. That separation gives me a way to evolve the AI component while keeping the product’s constraints explicit.

The current configuration uses Ollama’s hosted service. I am not claiming that CV processing happens entirely on the user’s machine. Running inference on infrastructure I control is a future option that open weights make possible.

A closed API could implement this workflow too. The additional value of open weights is the ability to work directly with the model, explore self-hosting, and investigate improvements beyond a provider’s hosted interface.

For a potential paid service handling personal career information, that flexibility matters: it gives me more choices about deployment, operating costs, and how the system develops.

Prize Categories

Best Use of Gemma

Gemma is central to the complete application journey: extracting the CV, understanding job requirements, finding supporting evidence, rewriting grounded content, and producing practice plans.

It also powers the private clarification flow for both major and minor gaps. When someone has relevant experience that their CV omitted, Gemma turns their explanation into proposed edits. Server-side checks ground those edits in their exact statements, and explicit user confirmation is required before anything is applied.

The pytest example shows this in practice: a missing preferred skill becomes a proposed skills-list addition supported by the person’s own words. The application then reassesses the role using its deterministic scoring rules.

This combines Gemma’s language capabilities with evidence checks and human review at the point where personal claims change.

Best Use of Render

Render hosts Job Ready’s FastAPI backend, Svelte interface, and PostgreSQL database.

I also added a Render Blueprint in render.yaml to make deployment straightforward. It defines the web service, database connection, health check, and environment configuration, so someone deploying the project does not have to configure each resource manually.

With the repository and an Ollama API key ready, setup takes around five minutes, plus build and provisioning time.

The deployed backend handles CV processing, Gemma requests, private clarification conversations, saved assessments, and eligible PDF downloads.

Best Use of a .tech Domain 🆕

Job Ready is live at jobready.tech, giving the project a clear, memorable address that matches its purpose: helping people prepare for their next role.

The domain brings the complete experience together—from uploading a CV and checking a role to clarifying experience with Gemma and sharing a profile with employers.