ResumeEngine

The problem

When applying to software engineering roles, tailoring a resume to each job description is genuinely helpful, but the process is repetitive and fragmented.

My manual workflow usually looked like this:

1. Keeping my complete career history in a master document.
2. Pasting my experience and a target job description into an LLM to identify gaps and suggest tailored bullet points.
3. Copying the generated points back out, adjusting the tone and phrasing.
4. Manually updating a LaTeX resume template with the new text.
5. Compiling and exporting the PDF.
6. Repeating the entire loop from scratch for the next application.

None of the individual tools were bad. An LLM is great at comparing text, LaTeX is great at typesetting, and local documents are great for drafting. But switching back and forth between four disconnected windows for every single job application created constant friction.

Why I built it

I built ResumeEngine because I was doing this process repeatedly and wanted to eliminate the manual glue work.

Rather than treating resume tailoring as a prompt-and-paste exercise, I wanted a single tool that could hold my core background, ingest a job description, suggest relevant adjustments, and give me an immediate, export-ready preview.

It started as a personal utility to speed up my own job search, but the problem was common enough that turning it into a complete, standalone application made sense.

The product

ResumeEngine is a deployed web application structured around a clean, linear workflow:

• Master Profile: You maintain your complete work history, projects, education, and skills in one central place.
• Job Description Input: You provide the target role details and requirements.
• Tailoring Engine: The system evaluates the job description against your master profile to highlight relevant achievements and reframe bullet points.
• Instant Preview: A formatted preview lets you inspect, edit, and fine-tune every section directly.
• Export: The final output is generated into a clean, structured resume format ready for submission.

Key product decisions

Master profile as the single source of truth

Instead of forcing users to rewrite or re-upload resumes for every application, the master profile holds the complete history. Tailoring creates a focused variation from that source rather than overwriting original data.

Focused tailoring instead of open-ended chat

General-purpose conversational AI often hallucinates structure or produces inconsistent formatting. ResumeEngine uses structured inputs and targeted tailoring steps so the output strictly adheres to standard resume sections and layouts.

Preview-first editing

Generated text is never final without review. The interface emphasizes side-by-side verification so users can edit wording, remove irrelevant suggestions, and verify layout before exporting.

Straightforward onboarding

To keep friction low, authentication uses a lightweight email and OTP verification flow rather than requiring complex password management.

Engineering decisions

Structured profile modeling

The data model in MongoDB is structured around distinct resume entities—work experiences, technical skills, projects, and educational milestones. This schema makes it straightforward to select, filter, and adapt specific entries during the tailoring step without breaking document structure.

API and backend architecture

The backend is built with Node.js and Express, exposing REST endpoints for profile CRUD operations, tailoring requests, and session management. The tailoring logic is separated into dedicated backend services rather than being embedded directly in the API routes.

Thoughtful data handling

I designed the application carefully around what personal information is included in the LLM workflow, and the tailoring prompt focuses on the profile information relevant to the job.

Deterministic output formatting

The rendering layer maps tailored JSON data into structured layout templates, helping keep the layout and formatting consistent across exports.

Building the product

Building ResumeEngine end to end involved much more than integrating an LLM API:

• Frontend Craft: Designing and building a responsive React interface with real-time previewing and granular section editing.
• Backend Infrastructure: Implementing REST APIs, session management, and database queries in Node.js and MongoDB.
• Auth & Communication: Setting up OTP verification and transactional email delivery.
• Deployment & Reliability: Managing deployment, production configuration, and domain setup.
• Iteration: Refining UI layouts and prompt constraints based on real application runs.

Current state

ResumeEngine is live and deployed at resumeengine.online.

The core tailoring, profile management, preview, and export workflows are fully operational in production and used to generate tailored resumes.

What I learned

• AI is only a feature, not the product: The hardest parts of ResumeEngine were state management, schema validation, auth workflows, and layout determinism—not the LLM call itself.
• Constraints improve output: Unconstrained text generation creates broken formats. Forcing AI outputs into strict schemas makes them dependable.
• Building for personal pain yields clarity: Because I used the tool myself, edge cases and workflow bottlenecks were obvious early in development.