ATSResume: an open source resume builder that runs on Next.js

A form-driven editor, not a document file

ATSResume is a resume builder whose pitch is to produce a resume that gets through applicant tracking systems, and it is deployed at atsresume.vercel.app. The interesting thing about the project for a developer is not the pitch but the shape of the implementation.

It is a Next.js application written in JavaScript with TypeScript configuration files, styled with Tailwind and PostCSS, and it uses `react-beautiful-dnd` for drag and drop and `react-icons` for iconography. The dependency list also includes `react-highlight-menu`, which suggests a context menu for quick actions on selected text.

The manifest is small and shows the shape of the project:

  "scripts": {
    "dev": "next dev",
    "build": "next build",
    "start": "next start",
    "lint": "next lint"
  },

There is no backend service, no database client and no account system in those dependencies, which tells you the whole application runs in the browser. The resume is edited as React state and rendered on the client, and the deployment is a static Next.js build served from a URL.

That has a direct consequence for anyone evaluating it. A resume is one of the few pieces of personal data that people care about keeping for years, and an application that keeps it in browser state is a good demonstration and a poor archive. The repository listing contains a `src/` directory, a `public/` directory and configuration files, and no schema, no export routine and no storage documentation, so where a saved resume lives is not something the repository answers.

Eleven sections and the fields each one holds

The README's section list is the closest thing to a data model in the project, and it is worth reading as one. There are eleven sections: Personal Information, Social Media, Summary, Educations, Work Experience, Projects, Technical Skills, Soft Skills, Languages, Additional Skills and Certifications.

Each section has its own fields. Personal Information holds name, email, phone, address and a profile picture. Educations holds degree, institute, start date and end date. Work Experience holds company, designation, description, key achievements, start date and end date, and the description is marked optional. Projects holds project name, description, key achievements, start date and end date, again with the description optional.

The remaining sections are simpler: Social Media takes links, Summary takes a summary, Technical Skills, Soft Skills, Languages, Additional Skills and Certifications each take a list of free-form entries.

Two design points are worth pulling out. The first is that work experience and projects are modelled almost identically, both carrying key achievements, which tells you the editor treats a project as a job with slightly different labels. The second is that the optional description in both sections implies the form lets you leave the prose out and rely on achievements alone, which is a deliberate choice given the section on key achievements is given its own heading later in the README.

Because the repository has no schema file, this list is the only description of the shape of a resume, and it is a front end description rather than a data format. Anyone who wants the same data in their own tooling has nothing to import.

Reordering sections and the key achievements advice

The change log in the README has one entry: drag and drop sections to reorder them in the resume, specifically Work Experience, Projects and Skills. That is the whole of the recorded change history, and it tells you the feature set is still early.

The reordering is implemented with `react-beautiful-dnd`, the drag and drop library React maintains for list reordering. Reordering the major blocks of a resume is a real usability question, since the order of sections changes how quickly a recruiter reads the top of the page, and it is one of the few things a resume builder can do that a plain text file cannot.

The other thing the README dwells on is key achievements, which it calls the most important part of your resume. The guidance is to add them to the work experience and to projects, to make the resume more attractive and increase the chances of being noticed by employers, and to add them by clicking on the new line. The third point is the interesting one. It tells you key achievements are entered as repeated list items rather than as a single free-text block, which is a structured approach rather than a paragraph.

The README also carries screenshots of PageSpeed Insights, which is the project's own statement about the performance of the deployed site. That is a reasonable thing for a portfolio-grade project to point at, though it says nothing about how the site behaves under load or on a slow connection, and the repository contains no performance test or budget to check it against.

The AI features belong to a partner service

The most prominent part of the README is a promotional block for a separate product. ATSResume's author has partnered with CVInsight, and the block links to an AI resume studio that generates PDFs, a one-click job tailoring tool that rewrites a resume from a pasted job description, and a resume roasting tool that gives recruiter-style feedback, with a discount code for checkout.

None of that is in this repository. The project is the resume builder, and the AI capabilities are offered by a different vendor, reached by a link, with a commercial arrangement behind it. That is worth stating plainly because the README's opening paragraph talks about analysing and optimising a resume, which can read as though the open source project itself does that.

For an evaluator the distinction matters in two directions. It does not add features to the open source project, so anyone expecting the AI tooling to be self-hostable will be disappointed. And it does introduce a dependency on a third party for the parts of the workflow that feel most modern, which means the parts that are actually open source are the form, the layout and the drag and drop.

The repository also links a resume score tool hosted on another site, resumego.net, which is presented as a separate demo of what a score looks like. Again, the scoring is not implemented here.

Running it yourself with Docker

The deployment story is complete enough to be useful, and there are two ways to get it running.

The plain way is the standard Next.js one, with the scripts above: `yarn dev` for development, `yarn build` and `yarn start` for a production run, and `yarn lint` for the checks. The repository ships a `yarn.lock`, and the Dockerfile installs with a frozen lockfile, so a deployment is reproducible.

The container route is a three-stage build. Dependencies are installed in a `deps` stage, the application is built in a `builder` stage, and the runner stage copies only what is needed:

# 1. Dependencies
FROM node:18-alpine AS deps
WORKDIR /app

COPY package.json yarn.lock ./
RUN yarn install --frozen-lockfile

# 2. Builder
FROM node:18-alpine AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY . .
RUN yarn build

The runner stage then runs as a non-root user, which is the part that matters in a container image:

# 3. Runner (production)
FROM node:18-alpine AS runner
WORKDIR /app
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001
COPY --from=builder /app/public ./public
COPY --from=builder /app/.next/standalone ./
COPY --from=builder /app/.next/static ./.next/static
USER nextjs
ENTRYPOINT ["node", "server.js"]

Copying `.next/standalone` is the standard Next.js output for a minimal image, and the non-root `nextjs` user with a fixed uid is the conventional choice.

The compose file is correspondingly short, building from the local Dockerfile and mapping a single port:

version: "3.9"

services:
  app:
    build: .
    ports:
      - "3000:3000"
    restart: unless-stopped

There is no database service, no volume and no environment variable in that file, which confirms the earlier point that this application has no server-side state. A self-hosted deployment will restart and lose whatever was in the browser unless the user exported it, and the repository does not say how.

Version drift and the undocumented parts

A few things in the repository are worth flagging before anyone builds on it.

The manifest pairs `next` 15.5.9 with `react` 18.2.0 and `react-dom` 18.2.0, and with `eslint-config-next` 13.1.6, which is several major versions behind the Next version in the same file. The lint script still calls `next lint`, the command Next removed in later major versions. Whether that combination works as shipped is not something the repository states, and the same file pins eslint at 8.33.0 with typescript at 5.0.4. For a project whose own build tooling is three years behind its framework dependency, the first task for a new maintainer is likely to be upgrading the lint and type toolchain.

The contributing section asks contributors to make sure to update tests as appropriate, but the repository listing has no test directory, so there is no suite to update. The presence of `tests` in the contribution guidance and its absence in the tree is a small gap that a reader should know about before offering a pull request.

The bigger gap is the absence of documentation for the three things that matter most to a user. Where is the resume stored? How is it exported, and to what format? And what does the ATS optimisation actually consist of, beyond the claim? The README documents the sections, the fields and the reordering, and stops there. The repository is not archived and the last push was on 2026-10-01, with no GitHub releases published, so the changelog in the repository is the only version history a user has.

Editorial conclusion

ATSResume suits a developer who wants to self-host a resume builder for themselves or for a community, who is comfortable editing React and Tailwind, and who can accept that the editor holds the resume in the browser rather than in a file they control. It does not suit a job seeker who wants a data-first CV they can keep in version control, and it does not give you the AI tailoring the README advertises, because that lives in a separate paid service. Before adopting, read the repository for what it does not document, in particular where the resume data is stored and how it is exported, and check the dependency versions, since the manifest pairs Next 15.5.9 with React 18.2.0 and eslint-config-next 13.1.6.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. Project website
4. README
5. sauravhathi/atsresume on GitHub