# How to Build a Resume Builder Backend with Replit
- Tool: How to Build with Replit
- Difficulty: Intermediate
- Compatibility: Replit Free
- Last updated: April 2026
## 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.
## Before you start
- 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)
## Step-by-step guide
### 1. 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.
```
// Build a resume builder backend with Express and PostgreSQL using Drizzle ORM.
// Use Replit Auth for user authentication.
//
// Tables:
// 1. resumes: id serial primary key, user_id text not null, title text default 'Untitled Resume',
// template_id text default 'classic', is_public boolean default false,
// created_at timestamp default now(), updated_at timestamp default now()
// 2. personal_info: id serial, resume_id integer references resumes not null unique,
// full_name text not null, email text, phone text, location text,
// website text, linkedin text, summary text
// 3. experiences: id serial, resume_id integer references resumes not null,
// company text not null, title text not null, location text,
// start_date date not null, end_date date, is_current boolean default false,
// description text, highlights text[] (bullet points array), position integer default 0
// 4. education: id serial, resume_id integer references resumes not null,
// institution text not null, degree text not null, field text,
// start_date date, end_date date, gpa text, highlights text[], position integer default 0
// 5. skills: id serial, resume_id integer references resumes not null,
// category text not null (e.g. 'Programming Languages'),
// items text[] not null, position integer default 0
// 6. projects: id serial, resume_id integer references resumes not null,
// name text not null, description text, url text,
// technologies text[], position integer default 0
// 7. certifications: id serial, resume_id integer references resumes not null,
// name text not null, issuer text, date date, url text, position integer default 0
//
// Routes for each section: GET/POST/PUT/DELETE + PATCH reorder
// Plus: POST /api/resumes/:id/export/pdf, GET /api/resumes/:id/preview (HTML),
// POST /api/resumes/:id/duplicate, GET /api/resumes (list)
//
// 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.
### 2. 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.
```
const express = require('express');
const { db } = require('../db');
const {
resumes, personalInfo, experiences, education,
skills, projects, certifications,
} = require('../schema');
const { eq, and, asc } = require('drizzle-orm');
const { withDbRetry } = require('../lib/retryDb');
const router = express.Router();
router.get('/api/resumes/:id', async (req, res) => {
if (!req.user) return res.status(401).json({ error: 'Login required' });
const resumeId = parseInt(req.params.id);
const [resume] = await db.select().from(resumes)
.where(and(eq(resumes.id, resumeId), eq(resumes.userId, req.user.id)))
.limit(1);
if (!resume) return res.status(404).json({ error: 'Resume not found' });
// Load all sections in parallel
const [info, exp, edu, sk, proj, certs] = await Promise.all([
db.select().from(personalInfo).where(eq(personalInfo.resumeId, resumeId)).limit(1),
db.select().from(experiences).where(eq(experiences.resumeId, resumeId)).orderBy(asc(experiences.position)),
db.select().from(education).where(eq(education.resumeId, resumeId)).orderBy(asc(education.position)),
db.select().from(skills).where(eq(skills.resumeId, resumeId)).orderBy(asc(skills.position)),
db.select().from(projects).where(eq(projects.resumeId, resumeId)).orderBy(asc(projects.position)),
db.select().from(certifications).where(eq(certifications.resumeId, resumeId)).orderBy(asc(certifications.position)),
]);
return res.json({
...resume,
personalInfo: info[0] || null,
experiences: exp,
education: edu,
skills: sk,
projects: proj,
certifications: certs,
});
});
// Duplicate a resume with all sections
router.post('/api/resumes/:id/duplicate', async (req, res) => {
if (!req.user) return res.status(401).json({ error: 'Login required' });
const resumeId = parseInt(req.params.id);
// Get original full resume
const fullRes = await fetch(`http://localhost:${process.env.PORT || 3000}/api/resumes/${resumeId}`, {
headers: { cookie: req.headers.cookie },
}).then(r => r.json());
if (!fullRes.id) return res.status(404).json({ error: 'Resume not found' });
// Create new resume
const [newResume] = await db.insert(resumes).values({
userId: req.user.id,
title: fullRes.title + ' (Copy)',
templateId: fullRes.templateId,
}).returning();
const newId = newResume.id;
// Copy all sections
if (fullRes.personalInfo) {
const { id: _id, resumeId: _rid, ...info } = fullRes.personalInfo;
await db.insert(personalInfo).values({ ...info, resumeId: newId });
}
if (fullRes.experiences.length) {
await db.insert(experiences).values(
fullRes.experiences.map(({ id: _id, resumeId: _rid, ...e }) => ({ ...e, resumeId: newId }))
);
}
return res.status(201).json({ id: newId, title: newResume.title });
});
module.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.
### 3. 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.
```
const express = require('express');
const { db } = require('../db');
const { experiences } = require('../schema');
const { eq, and } = require('drizzle-orm');
const router = express.Router();
router.post('/api/resumes/:resumeId/experiences', express.json(), async (req, res) => {
if (!req.user) return res.status(401).json({ error: 'Login required' });
const { company, title, location, startDate, endDate, isCurrent, description, highlights } = req.body;
if (!company || !title || !startDate) {
return res.status(400).json({ error: 'company, title, and startDate are required' });
}
// Get current max position
const maxPos = await db.execute({
sql: 'SELECT COALESCE(MAX(position), -1) AS max FROM experiences WHERE resume_id = $1',
params: [parseInt(req.params.resumeId)],
});
const nextPos = (maxPos.rows[0]?.max || -1) + 1;
const row = await db.insert(experiences).values({
resumeId: parseInt(req.params.resumeId),
company, title, location: location || null,
startDate: new Date(startDate),
endDate: endDate ? new Date(endDate) : null,
isCurrent: Boolean(isCurrent),
description: description || null,
highlights: highlights || [],
position: nextPos,
}).returning();
return res.status(201).json(row[0]);
});
router.put('/api/resumes/:resumeId/experiences/:id', express.json(), async (req, res) => {
if (!req.user) return res.status(401).json({ error: 'Login required' });
const { company, title, location, startDate, endDate, isCurrent, description, highlights } = req.body;
const updated = await db.update(experiences)
.set({
...(company && { company }), ...(title && { title }),
location: location || null,
...(startDate && { startDate: new Date(startDate) }),
endDate: endDate ? new Date(endDate) : null,
isCurrent: isCurrent !== undefined ? Boolean(isCurrent) : undefined,
...(description !== undefined && { description }),
...(highlights && { highlights }),
})
.where(eq(experiences.id, parseInt(req.params.id)))
.returning();
if (!updated[0]) return res.status(404).json({ error: 'Not found' });
return res.json(updated[0]);
});
// Reorder: accepts array of {id, position} and batch-updates positions
router.patch('/api/resumes/:resumeId/experiences/reorder', express.json(), async (req, res) => {
if (!req.user) return res.status(401).json({ error: 'Login required' });
const { order } = req.body; // [{id: 1, position: 0}, {id: 2, position: 1}]
if (!Array.isArray(order)) return res.status(400).json({ error: 'order array required' });
await Promise.all(
order.map(({ id, position }) =>
db.update(experiences)
.set({ position: parseInt(position) })
.where(eq(experiences.id, parseInt(id)))
)
);
return res.json({ reordered: order.length });
});
module.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.
### 4. 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.
```
const express = require('express');
const PDFDocument = require('pdfkit');
const { loadFullResume } = require('../lib/resumeLoader'); // helper that calls the GET logic
const router = express.Router();
// HTML preview — fast, used for client-side live preview
router.get('/api/resumes/:id/preview', async (req, res) => {
if (!req.user) return res.status(401).json({ error: 'Login required' });
const resume = await loadFullResume(parseInt(req.params.id), req.user.id);
if (!resume) return res.status(404).json({ error: 'Not found' });
const html = renderResumeHtml(resume);
res.setHeader('Content-Type', 'text/html');
return res.send(html);
});
// PDF export — server-side rendering with pdfkit
router.post('/api/resumes/:id/export/pdf', async (req, res) => {
if (!req.user) return res.status(401).json({ error: 'Login required' });
const resume = await loadFullResume(parseInt(req.params.id), req.user.id);
if (!resume) return res.status(404).json({ error: 'Not found' });
const doc = new PDFDocument({ margin: 50, size: 'LETTER' });
const filename = `${(resume.personalInfo?.fullName || 'resume').replace(/\s+/g, '_')}.pdf`;
res.setHeader('Content-Type', 'application/pdf');
res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
doc.pipe(res);
// Header: Name and contact info
if (resume.personalInfo) {
const p = resume.personalInfo;
doc.fontSize(20).font('Helvetica-Bold').text(p.fullName || '', { align: 'center' });
const contact = [p.email, p.phone, p.location, p.website].filter(Boolean).join(' | ');
doc.fontSize(10).font('Helvetica').text(contact, { align: 'center' });
if (p.summary) {
doc.moveDown(0.5).fontSize(10).text(p.summary);
}
doc.moveDown(1);
}
// Experience section
if (resume.experiences?.length) {
doc.fontSize(13).font('Helvetica-Bold').text('EXPERIENCE');
doc.moveTo(50, doc.y).lineTo(560, doc.y).stroke();
for (const exp of resume.experiences) {
doc.moveDown(0.4).fontSize(11).font('Helvetica-Bold').text(exp.title);
doc.fontSize(10).font('Helvetica').text(`${exp.company} | ${exp.location || ''}`, { continued: true });
const dateRange = exp.isCurrent ? `${exp.startDate?.slice(0,7)} – Present` : `${exp.startDate?.slice(0,7)} – ${exp.endDate?.slice(0,7) || ''}`;
doc.text(dateRange, { align: 'right' });
if (exp.highlights?.length) {
for (const bullet of exp.highlights) {
doc.fontSize(9).text(`• ${bullet}`, { indent: 10 });
}
}
}
doc.moveDown(1);
}
doc.end();
});
function renderResumeHtml(resume) {
const p = resume.personalInfo || {};
return `
${p.fullName || ''}
${[p.email,p.phone,p.location].filter(Boolean).join(' | ')}
${p.summary ? `${p.summary}
` : ''}
${resume.experiences?.length ? `Experience
${resume.experiences.map(e =>
`
${e.highlights?.length ? `
${e.highlights.map(b => `- ${b}
`).join('')}
` : ''}