Build a Resume Builder Backend in Replit

TL;DR

Build a resume builder backend in Replit using Express and PostgreSQL in 1-2 hours. You'll store structured resume data (experience, education, skills, projects) and generate PDF exports using pdfkit. Replit Agent scaffolds the API and React editor with live preview — a Canva Resumes competitor backend.

What you're building

A resume builder backend stores resume data in a structured, normalized form — separate tables for each section type — and generates professional formatted output in PDF or HTML. This is fundamentally different from storing a resume as a single text blob: structured data means you can update one work experience entry without touching the rest, sort sections by position, and swap templates without re-entering any data.

Replit Agent builds the full backend with seven tables: a top-level resumes table and six section tables (personal_info, experiences, education, skills, projects, certifications). Each section table has a position column so users can reorder entries with drag-and-drop. The API mirrors this structure with RESTful routes per section type.

The key design decision is the preview architecture. Generating a PDF on every keystroke would be too slow. Instead, the Express API provides a GET /api/resumes/:id/preview route that renders the resume as styled HTML — fast enough for real-time updates. The PDF export only triggers when the user clicks the download button. The client-side React preview component mirrors the same HTML/CSS template structure so what you see in the editor exactly matches what you get in the PDF.

Final result

A resume builder backend API with structured section storage, position-based reordering, live HTML preview, and PDF export — plus a React editor with real-time preview.

Tech stack

ReplitIDE & Hosting

ExpressBackend Framework

PostgreSQLDatabase

Drizzle ORMDatabase ORM

Replit AuthAuth

pdfkitPDF Generation

Prerequisites

A Replit account (Free tier is sufficient)
No external API keys needed for the core build
pdfkit npm package (Agent will install it)
Basic understanding of resume structure (sections, bullet points)

Build steps

Scaffold the project with Replit Agent

Create a new Replit App and paste this prompt. Agent builds the full resume backend with all seven tables and the React editor skeleton.

prompt.txt

1// Build a resume builder backend with Express and PostgreSQL using Drizzle ORM.
2// Use Replit Auth for user authentication.
3//
4// Tables:
5// 1. resumes: id serial primary key, user_id text not null, title text default 'Untitled Resume',
6//    template_id text default 'classic', is_public boolean default false,
7//    created_at timestamp default now(), updated_at timestamp default now()
8// 2. personal_info: id serial, resume_id integer references resumes not null unique,
9//    full_name text not null, email text, phone text, location text,
10//    website text, linkedin text, summary text
11// 3. experiences: id serial, resume_id integer references resumes not null,
12//    company text not null, title text not null, location text,
13//    start_date date not null, end_date date, is_current boolean default false,
14//    description text, highlights text[] (bullet points array), position integer default 0
15// 4. education: id serial, resume_id integer references resumes not null,
16//    institution text not null, degree text not null, field text,
17//    start_date date, end_date date, gpa text, highlights text[], position integer default 0
18// 5. skills: id serial, resume_id integer references resumes not null,
19//    category text not null (e.g. 'Programming Languages'),
20//    items text[] not null, position integer default 0
21// 6. projects: id serial, resume_id integer references resumes not null,
22//    name text not null, description text, url text,
23//    technologies text[], position integer default 0
24// 7. certifications: id serial, resume_id integer references resumes not null,
25//    name text not null, issuer text, date date, url text, position integer default 0
26//
27// Routes for each section: GET/POST/PUT/DELETE + PATCH reorder
28// Plus: POST /api/resumes/:id/export/pdf, GET /api/resumes/:id/preview (HTML),
29//       POST /api/resumes/:id/duplicate, GET /api/resumes (list)
30//
31// Install pdfkit. Bind to 0.0.0.0:3000.

Pro tip: After scaffolding, immediately test the GET /api/resumes/:id/preview route — if the HTML renders in a browser tab, your template logic is working before you wire up the React frontend.

Expected result: Running Express app with all seven tables. POST /api/resumes creates a new resume. GET /api/resumes returns the user's resume list.

Build the full resume retrieval with joined sections

The main data-fetch route returns a complete resume with all sections joined — used both for the editor and for export.

server/routes/resumes.js

1const express = require('express');
2const { db } = require('../db');
3const {
4  resumes, personalInfo, experiences, education,
5  skills, projects, certifications,
6} = require('../schema');
7const { eq, and, asc } = require('drizzle-orm');
8const { withDbRetry } = require('../lib/retryDb');
9
10const router = express.Router();
11
12router.get('/api/resumes/:id', async (req, res) => {
13  if (!req.user) return res.status(401).json({ error: 'Login required' });
14  const resumeId = parseInt(req.params.id);
15
16  const [resume] = await db.select().from(resumes)
17    .where(and(eq(resumes.id, resumeId), eq(resumes.userId, req.user.id)))
18    .limit(1);
19  if (!resume) return res.status(404).json({ error: 'Resume not found' });
20
21  // Load all sections in parallel
22  const [info, exp, edu, sk, proj, certs] = await Promise.all([
23    db.select().from(personalInfo).where(eq(personalInfo.resumeId, resumeId)).limit(1),
24    db.select().from(experiences).where(eq(experiences.resumeId, resumeId)).orderBy(asc(experiences.position)),
25    db.select().from(education).where(eq(education.resumeId, resumeId)).orderBy(asc(education.position)),
26    db.select().from(skills).where(eq(skills.resumeId, resumeId)).orderBy(asc(skills.position)),
27    db.select().from(projects).where(eq(projects.resumeId, resumeId)).orderBy(asc(projects.position)),
28    db.select().from(certifications).where(eq(certifications.resumeId, resumeId)).orderBy(asc(certifications.position)),
29  ]);
30
31  return res.json({
32    ...resume,
33    personalInfo: info[0] || null,
34    experiences: exp,
35    education: edu,
36    skills: sk,
37    projects: proj,
38    certifications: certs,
39  });
40});
41
42// Duplicate a resume with all sections
43router.post('/api/resumes/:id/duplicate', async (req, res) => {
44  if (!req.user) return res.status(401).json({ error: 'Login required' });
45  const resumeId = parseInt(req.params.id);
46
47  // Get original full resume
48  const fullRes = await fetch(`http://localhost:${process.env.PORT || 3000}/api/resumes/${resumeId}`, {
49    headers: { cookie: req.headers.cookie },
50  }).then(r => r.json());
51
52  if (!fullRes.id) return res.status(404).json({ error: 'Resume not found' });
53
54  // Create new resume
55  const [newResume] = await db.insert(resumes).values({
56    userId: req.user.id,
57    title: fullRes.title + ' (Copy)',
58    templateId: fullRes.templateId,
59  }).returning();
60
61  const newId = newResume.id;
62
63  // Copy all sections
64  if (fullRes.personalInfo) {
65    const { id: _id, resumeId: _rid, ...info } = fullRes.personalInfo;
66    await db.insert(personalInfo).values({ ...info, resumeId: newId });
67  }
68  if (fullRes.experiences.length) {
69    await db.insert(experiences).values(
70      fullRes.experiences.map(({ id: _id, resumeId: _rid, ...e }) => ({ ...e, resumeId: newId }))
71    );
72  }
73
74  return res.status(201).json({ id: newId, title: newResume.title });
75});
76
77module.exports = router;

Pro tip: Use Promise.all() to load all six section tables in parallel — this cuts the total database time from 6 sequential queries to the time of the slowest single query, typically 3-5x faster for a full resume load.

Expected result: GET /api/resumes/1 returns a complete resume object with personalInfo, experiences array, education array, skills array, projects array, and certifications array.

Add the section CRUD routes with position-based reordering

Each section type needs create, update, delete, and reorder endpoints. The reorder route accepts a new position array and updates all affected rows.

server/routes/experiences.js

1const express = require('express');
2const { db } = require('../db');
3const { experiences } = require('../schema');
4const { eq, and } = require('drizzle-orm');
5
6const router = express.Router();
7
8router.post('/api/resumes/:resumeId/experiences', express.json(), async (req, res) => {
9  if (!req.user) return res.status(401).json({ error: 'Login required' });
10  const { company, title, location, startDate, endDate, isCurrent, description, highlights } = req.body;
11  if (!company || !title || !startDate) {
12    return res.status(400).json({ error: 'company, title, and startDate are required' });
13  }
14  // Get current max position
15  const maxPos = await db.execute({
16    sql: 'SELECT COALESCE(MAX(position), -1) AS max FROM experiences WHERE resume_id = $1',
17    params: [parseInt(req.params.resumeId)],
18  });
19  const nextPos = (maxPos.rows[0]?.max || -1) + 1;
20
21  const row = await db.insert(experiences).values({
22    resumeId: parseInt(req.params.resumeId),
23    company, title, location: location || null,
24    startDate: new Date(startDate),
25    endDate: endDate ? new Date(endDate) : null,
26    isCurrent: Boolean(isCurrent),
27    description: description || null,
28    highlights: highlights || [],
29    position: nextPos,
30  }).returning();
31  return res.status(201).json(row[0]);
32});
33
34router.put('/api/resumes/:resumeId/experiences/:id', express.json(), async (req, res) => {
35  if (!req.user) return res.status(401).json({ error: 'Login required' });
36  const { company, title, location, startDate, endDate, isCurrent, description, highlights } = req.body;
37  const updated = await db.update(experiences)
38    .set({
39      ...(company && { company }), ...(title && { title }),
40      location: location || null,
41      ...(startDate && { startDate: new Date(startDate) }),
42      endDate: endDate ? new Date(endDate) : null,
43      isCurrent: isCurrent !== undefined ? Boolean(isCurrent) : undefined,
44      ...(description !== undefined && { description }),
45      ...(highlights && { highlights }),
46    })
47    .where(eq(experiences.id, parseInt(req.params.id)))
48    .returning();
49  if (!updated[0]) return res.status(404).json({ error: 'Not found' });
50  return res.json(updated[0]);
51});
52
53// Reorder: accepts array of {id, position} and batch-updates positions
54router.patch('/api/resumes/:resumeId/experiences/reorder', express.json(), async (req, res) => {
55  if (!req.user) return res.status(401).json({ error: 'Login required' });
56  const { order } = req.body; // [{id: 1, position: 0}, {id: 2, position: 1}]
57  if (!Array.isArray(order)) return res.status(400).json({ error: 'order array required' });
58
59  await Promise.all(
60    order.map(({ id, position }) =>
61      db.update(experiences)
62        .set({ position: parseInt(position) })
63        .where(eq(experiences.id, parseInt(id)))
64    )
65  );
66  return res.json({ reordered: order.length });
67});
68
69module.exports = router;

Pro tip: The reorder route uses Promise.all() to update all positions in parallel. For very long resumes, consider using a single SQL UPDATE with a CASE WHEN expression instead: UPDATE experiences SET position = CASE WHEN id=1 THEN 0 WHEN id=2 THEN 1 END WHERE id IN (1, 2). This is more efficient for 10+ entries.

Expected result: POST /api/resumes/1/experiences creates an experience entry. PATCH /api/resumes/1/experiences/reorder with [{id:2, position:0}, {id:1, position:1}] swaps the display order.

Build the PDF export and HTML preview routes

The PDF export uses pdfkit to render a formatted resume server-side. The HTML preview route returns the same data as a styled HTML string for the client-side live preview.

server/routes/export.js

1const express = require('express');
2const PDFDocument = require('pdfkit');
3const { loadFullResume } = require('../lib/resumeLoader'); // helper that calls the GET logic
4
5const router = express.Router();
6
7// HTML preview — fast, used for client-side live preview
8router.get('/api/resumes/:id/preview', async (req, res) => {
9  if (!req.user) return res.status(401).json({ error: 'Login required' });
10  const resume = await loadFullResume(parseInt(req.params.id), req.user.id);
11  if (!resume) return res.status(404).json({ error: 'Not found' });
12
13  const html = renderResumeHtml(resume);
14  res.setHeader('Content-Type', 'text/html');
15  return res.send(html);
16});
17
18// PDF export — server-side rendering with pdfkit
19router.post('/api/resumes/:id/export/pdf', async (req, res) => {
20  if (!req.user) return res.status(401).json({ error: 'Login required' });
21  const resume = await loadFullResume(parseInt(req.params.id), req.user.id);
22  if (!resume) return res.status(404).json({ error: 'Not found' });
23
24  const doc = new PDFDocument({ margin: 50, size: 'LETTER' });
25  const filename = `${(resume.personalInfo?.fullName || 'resume').replace(/\s+/g, '_')}.pdf`;
26
27  res.setHeader('Content-Type', 'application/pdf');
28  res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
29  doc.pipe(res);
30
31  // Header: Name and contact info
32  if (resume.personalInfo) {
33    const p = resume.personalInfo;
34    doc.fontSize(20).font('Helvetica-Bold').text(p.fullName || '', { align: 'center' });
35    const contact = [p.email, p.phone, p.location, p.website].filter(Boolean).join('  |  ');
36    doc.fontSize(10).font('Helvetica').text(contact, { align: 'center' });
37    if (p.summary) {
38      doc.moveDown(0.5).fontSize(10).text(p.summary);
39    }
40    doc.moveDown(1);
41  }
42
43  // Experience section
44  if (resume.experiences?.length) {
45    doc.fontSize(13).font('Helvetica-Bold').text('EXPERIENCE');
46    doc.moveTo(50, doc.y).lineTo(560, doc.y).stroke();
47    for (const exp of resume.experiences) {
48      doc.moveDown(0.4).fontSize(11).font('Helvetica-Bold').text(exp.title);
49      doc.fontSize(10).font('Helvetica').text(`${exp.company}  |  ${exp.location || ''}`, { continued: true });
50      const dateRange = exp.isCurrent ? `${exp.startDate?.slice(0,7)} – Present` : `${exp.startDate?.slice(0,7)} – ${exp.endDate?.slice(0,7) || ''}`;
51      doc.text(dateRange, { align: 'right' });
52      if (exp.highlights?.length) {
53        for (const bullet of exp.highlights) {
54          doc.fontSize(9).text(`• ${bullet}`, { indent: 10 });
55        }
56      }
57    }
58    doc.moveDown(1);
59  }
60
61  doc.end();
62});
63
64function renderResumeHtml(resume) {
65  const p = resume.personalInfo || {};
66  return `<!DOCTYPE html><html><head><style>
67    body{font-family:Georgia,serif;max-width:800px;margin:40px auto;padding:0 20px;color:#222;}
68    h1{text-align:center;font-size:24px;margin-bottom:4px;}
69    .contact{text-align:center;font-size:13px;color:#555;margin-bottom:16px;}
70    h2{font-size:14px;border-bottom:1px solid #333;padding-bottom:2px;text-transform:uppercase;}
71    .item{margin-bottom:12px;} .item-header{display:flex;justify-content:space-between;}
72    .item-title{font-weight:bold;font-size:13px;} .item-sub{font-size:12px;color:#555;}
73    ul{margin:4px 0 0 16px;padding:0;font-size:12px;}
74  </style></head><body>
75    <h1>${p.fullName || ''}</h1>
76    <div class="contact">${[p.email,p.phone,p.location].filter(Boolean).join(' | ')}</div>
77    ${p.summary ? `<p style="font-size:13px">${p.summary}</p>` : ''}
78    ${resume.experiences?.length ? `<h2>Experience</h2>${resume.experiences.map(e =>
79      `<div class="item"><div class="item-header"><span class="item-title">${e.title} — ${e.company}</span><span class="item-sub">${e.startDate?.slice(0,7) || ''} – ${e.isCurrent ? 'Present' : (e.endDate?.slice(0,7) || '')}</span></div>
80      ${e.highlights?.length ? `<ul>${e.highlights.map(b => `<li>${b}</li>`).join('')}</ul>` : ''}</div>`).join('')}` : ''}
81  </body></html>`;
82}
83
84module.exports = router;

Pro tip: The HTML preview renders in an iframe in the React editor. When the user updates any section field, refetch GET /api/resumes/:id/preview with a 500ms debounce and update the iframe's srcdoc attribute — giving a live preview without a full page reload.

Expected result: GET /api/resumes/1/preview returns a full HTML resume. POST /api/resumes/1/export/pdf triggers a PDF file download with the candidate's name as the filename.

Build the React resume editor with live preview

Ask Agent to create the React frontend with the two-panel editor layout and section management forms.

prompt.txt

1// Ask Agent to build the React frontend with this prompt:
2// Build a React resume editor with a two-panel layout:
3//
4// Left panel (editing, 50% width):
5// - Resume title input at top (auto-saves via PUT /api/resumes/:id)
6// - Collapsible section cards: Personal Info, Experience, Education, Skills, Projects, Certifications
7// - Personal Info: form fields for name, email, phone, location, website, linkedin, summary textarea
8// - Experience: list of entries, each with Edit and Delete buttons
9//   'Add Experience' button opens a form: company, title, location, start/end dates, 'current job' checkbox
10//   Bullet highlights: dynamic list with Add/Remove buttons (each bullet is a text input)
11// - Education: same pattern as Experience
12// - Skills: category name input + comma-separated items textarea per skill group
13// - Projects: name, description, URL, technologies (comma-separated)
14// - Each section has drag handles for reordering — on drop, call PATCH .../reorder
15//
16// Right panel (live preview, 50% width):
17// - iframe showing GET /api/resumes/:id/preview
18// - Refetch preview with 500ms debounce on any form change via iframe.srcdoc update
19//
20// Top toolbar:
21// - Template selector dropdown (classic/modern/minimal) — changes resume.template_id
22// - 'Export PDF' button calls POST /api/resumes/:id/export/pdf and triggers download
23// - 'Duplicate' button calls POST /api/resumes/:id/duplicate
24//
25// Resume list page: card grid with title, last updated, and Edit/Duplicate/Delete buttons

Expected result: The editor shows two panels. Editing the name field in Personal Info updates the live preview in the right panel after 500ms. Clicking Export PDF downloads a formatted PDF.

Complete code

server/routes/resumes.js

1const express = require('express');
2const { db } = require('../db');
3const {
4  resumes, personalInfo, experiences, education, skills, projects, certifications,
5} = require('../schema');
6const { eq, and, asc } = require('drizzle-orm');
7const { withDbRetry } = require('../lib/retryDb');
8
9const router = express.Router();
10
11router.get('/api/resumes', async (req, res) => {
12  if (!req.user) return res.status(401).json({ error: 'Login required' });
13  const rows = await db.select().from(resumes)
14    .where(eq(resumes.userId, req.user.id))
15    .orderBy(resumes.updatedAt);
16  return res.json({ resumes: rows });
17});
18
19router.post('/api/resumes', express.json(), async (req, res) => {
20  if (!req.user) return res.status(401).json({ error: 'Login required' });
21  const { title, templateId } = req.body;
22  const row = await withDbRetry(() =>
23    db.insert(resumes).values({
24      userId: req.user.id,
25      title: title || 'Untitled Resume',
26      templateId: templateId || 'classic',
27    }).returning()
28  );
29  return res.status(201).json(row[0]);
30});
31
32router.get('/api/resumes/:id', async (req, res) => {
33  if (!req.user) return res.status(401).json({ error: 'Login required' });
34  const resumeId = parseInt(req.params.id);
35  const [resume] = await db.select().from(resumes)
36    .where(and(eq(resumes.id, resumeId), eq(resumes.userId, req.user.id))).limit(1);
37  if (!resume) return res.status(404).json({ error: 'Resume not found' });
38
39  const [info, exp, edu, sk, proj, certs] = await Promise.all([
40    db.select().from(personalInfo).where(eq(personalInfo.resumeId, resumeId)).limit(1),
41    db.select().from(experiences).where(eq(experiences.resumeId, resumeId)).orderBy(asc(experiences.position)),
42    db.select().from(education).where(eq(education.resumeId, resumeId)).orderBy(asc(education.position)),
43    db.select().from(skills).where(eq(skills.resumeId, resumeId)).orderBy(asc(skills.position)),
44    db.select().from(projects).where(eq(projects.resumeId, resumeId)).orderBy(asc(projects.position)),
45    db.select().from(certifications).where(eq(certifications.resumeId, resumeId)).orderBy(asc(certifications.position)),
46  ]);
47
48  return res.json({ ...resume, personalInfo: info[0] || null, experiences: exp, education: edu, skills: sk, projects: proj, certifications: certs });
49});
50
51router.put('/api/resumes/:id', express.json(), async (req, res) => {
52  if (!req.user) return res.status(401).json({ error: 'Login required' });
53  const { title, templateId } = req.body;
54  const updated = await db.update(resumes)
55    .set({ ...(title && { title }), ...(templateId && { templateId }), updatedAt: new Date() })
56    .where(and(eq(resumes.id, parseInt(req.params.id)), eq(resumes.userId, req.user.id)))
57    .returning();
58  if (!updated[0]) return res.status(404).json({ error: 'Not found' });
59  return res.json(updated[0]);
60});
61
62module.exports = router;

Customization ideas

AI bullet point suggestions

Add a POST /api/resumes/:id/ai/suggestions route that accepts a job title and calls the OpenAI API (key in Replit Secrets) to generate 5 impact-driven bullet points for that role. Display them in the experience editor as clickable suggestions.

Multiple PDF templates

Add a modern and minimal template alongside the default classic. Each template is a separate renderResumeHtml function and a separate pdfkit layout function. The template_id on the resume determines which function to call.

Public resume URL

Add a is_public boolean and a public_token column to resumes. A GET /r/:token endpoint renders the resume HTML without auth — a shareable link the job seeker can put in their email signature.

Resume import from LinkedIn

Add a POST /api/resumes/import/linkedin route that accepts a LinkedIn profile URL, scrapes the public profile using puppeteer (installed in Replit's nix environment), and pre-populates the resume sections from the scraped data.

Common pitfalls

Pitfall: Generating the PDF on every keystroke in the live preview

How to avoid: Use the HTML preview endpoint for real-time display — it renders in under 30ms. Only call the PDF export endpoint when the user explicitly clicks 'Download PDF'.

Pitfall: Storing the resume as a single text or JSON blob

How to avoid: Use the normalized schema with separate tables per section type and position columns for ordering. The GET /api/resumes/:id endpoint joins them all with Promise.all() for fast loading.

Pitfall: Forgetting to scope resume queries by user_id

How to avoid: Every SELECT, UPDATE, and DELETE on the resumes table must include WHERE user_id = req.user.id. Section tables (experiences, education, etc.) are protected by the resume_id foreign key as long as you verify resume ownership first.

Pitfall: Not handling the PostgreSQL sleep issue on export

How to avoid: Wrap the loadFullResume database calls in withDbRetry() so the first query after a sleep period automatically retries with a 250ms delay.

Best practices

Use Promise.all() to load all section tables in parallel when fetching a full resume — reduces load time from 6 sequential queries to a single round-trip time.
Provide an HTML preview endpoint (fast, ~30ms) for live editing and a separate PDF export endpoint (slower, ~300ms) for download — never generate PDF on every keystroke.
Use position integers for section ordering and a PATCH reorder endpoint — this avoids rewriting all rows on every drag-and-drop, only updating the moved items' positions.
Store highlights (bullet points) as a PostgreSQL text[] array column rather than a separate bullets table — arrays are perfect for ordered lists that don't need their own IDs or metadata.
Scope all resume queries by user_id even for section tables — verify ownership via the parent resume before operating on its children.
Use Drizzle Studio (Database tab in Replit sidebar) to quickly inspect and edit resume data during development without writing SQL queries.
Deploy on Autoscale — resume builders have low concurrent traffic with short bursts when users edit and export. Cold starts are acceptable.

AI prompts to try

Copy these prompts to build this project faster.

ChatGPT Prompt

I'm building a resume builder backend with Express and PostgreSQL using Drizzle ORM. I have separate tables for experiences, education, skills, projects, and certifications — each with a resume_id and a position integer. Help me write a loadFullResume(resumeId, userId) async function that fetches the parent resume (verifying userId matches), then loads all five section tables in parallel using Promise.all(), and returns a complete resume object with all sections as arrays. Also help me write the batch reorder function that accepts an array of {id, position} pairs and updates all positions efficiently.

Build Prompt

Add an AI-powered bullet point enhancement feature to the resume builder. Build a POST /api/resumes/:resumeId/experiences/:id/enhance route that takes the existing experience description and highlights, calls the OpenAI Chat Completions API (key from OPENAI_API_KEY in Replit Secrets) with a prompt like 'Transform these experience bullet points into strong, impact-driven resume bullets using the STAR method and starting each with an action verb. Include quantified results where possible.', and returns 5 enhanced bullet suggestions. Display the suggestions in the experience editor as clickable chips — clicking one adds it to the highlights array. Show a spinner during the API call and error message if the enhancement fails.

Frequently asked questions

How does the live preview work without regenerating the PDF constantly?

The live preview uses the GET /api/resumes/:id/preview route which returns styled HTML — not a PDF. HTML generation is instant (under 30ms). The React editor loads this HTML into an iframe with a 500ms debounce on changes. PDF generation only happens when the user clicks Export PDF.

Can I support multiple resume templates?

Yes. The template_id column on the resumes table selects which template to use. Create separate renderClassicHtml(), renderModernHtml(), and renderMinimalHtml() functions in server/lib/resumeTemplates.js. The preview and PDF export routes call the correct function based on resume.templateId.

What Replit plan do I need?

Free tier is sufficient. Replit Auth is built-in, PostgreSQL is free with 10GB storage, and Autoscale deployment is included. pdfkit is a standard npm package — no external API keys needed for the core build.

How do I handle dates in the experience entries?

Store start_date and end_date as PostgreSQL date columns (YYYY-MM-DD format). In the form, use an HTML date input. Send dates as ISO strings to the API. The pdfkit renderer formats them using JavaScript's Date object — slice to 'YYYY-MM' for the typical resume format.

Can users share their resume via a public URL?

Add a is_public boolean and a share_token (UUID) to the resumes table. A GET /r/:token endpoint loads the resume without auth checking. The owner toggles sharing from the editor toolbar. The public endpoint returns the same HTML preview response as the editor.

Should I deploy on Autoscale or Reserved VM?

Autoscale is ideal for a resume builder. Users edit in short bursts, often with long gaps between sessions. The cold start of 10-30 seconds is acceptable — the editor loading animation provides a natural buffer. Reserved VM would be overkill and costly for personal use.

Can RapidDev help build a custom resume builder platform?

Yes. RapidDev builds complete resume builder platforms with AI enhancement, LinkedIn import, team collaboration features, and custom branded PDF templates for HR tech startups. 600+ apps built, free consultation available.

How do I allow users to reorder bullet points within an experience entry?

The highlights column is a PostgreSQL text[] array — reorder is done client-side (drag in React, update the array order), then a single PUT /api/resumes/:id/experiences/:eid updates the entire highlights array. No separate reorder endpoint is needed for bullet points since the array is stored as a single column.

Talk to an Expert

Our team has built 600+ apps. Get personalized help with your project.

Book a free consultation

How to Build a Resume Builder Backend with Replit

What you'll build

What you'll build

What you're building

Final result

Tech stack

Prerequisites

Build steps

Scaffold the project with Replit Agent

Build the full resume retrieval with joined sections

Add the section CRUD routes with position-based reordering

Build the PDF export and HTML preview routes

Build the React resume editor with live preview

Complete code

Customization ideas

AI bullet point suggestions

Multiple PDF templates

Public resume URL

Resume import from LinkedIn

Common pitfalls

Best practices

AI prompts to try

Frequently asked questions

Talk to an Expert

Need help building your app?

We put the rapid in RapidDev

How to Build a Resume Builder Backend with Replit

What you'll build

What you're building

Final result

Tech stack

Prerequisites

Build steps

Scaffold the project with Replit Agent

Build the full resume retrieval with joined sections

Add the section CRUD routes with position-based reordering

Build the PDF export and HTML preview routes

Build the React resume editor with live preview

Complete code

Customization ideas

AI bullet point suggestions

Multiple PDF templates

Public resume URL

Resume import from LinkedIn

Common pitfalls

Best practices

AI prompts to try

Related builds

How to Build Recruitment Platform with Replit

How to Build Job Board with Replit

How to Build Certificate Generator with Replit

How to Build Admin Panel with Replit

How to Build Reporting Tool with Replit

Explore related guides

Frequently asked questions

Talk to an Expert

Need help building your app?

We put the rapid in RapidDev