Frequently Asked Questions

# Using the CLI
resume validate
 
# Or use the online validator
# Visit: https://jsonresume.org/schema

{
  "basics": {
    "name": "John Doe"
  }
}

{
  "work": [
    {
      "startDate": "2020-01-15",
      "endDate": "2023-06-30"
    }
  ]
}

{
  "basics": {
    "url": "https://example.com"
  }
}

{
  "work": [],
  "education": []
}

# Test with multiple themes to find the best fit
resume export resume.pdf --theme elegant
resume export resume.pdf --theme professional
resume export resume.pdf --theme spartacus

{
  "work": [
    {
      "name": "Company",
      "position": "Developer",
      "startDate": "2020-01-01",
      "summary": "Description here",
      "highlights": ["Achievement 1", "Achievement 2"]
    }
  ]
}

{
  "basics": {
    "summary": "Plain text works best. Avoid HTML tags or special characters like &, <, >"
  }
}

{
  "skills": [
    {
      "name": "JavaScript",
      "level": "Advanced",
      "keywords": ["React", "Node.js"]
    }
  ]
}

resume validate
 
# Example output:
# ✖ Error: /basics/email must be a valid email address
# ✖ Error: /work/0/startDate must match format "date"
# ✖ Error: /education is required

const Ajv = require('ajv');
const schema = require('resume-schema');
 
const ajv = new Ajv({ allErrors: true });
const validate = ajv.compile(schema);
 
const valid = validate(resumeData);
 
if (!valid) {
  console.log(validate.errors);
  // Detailed error array with field paths
}

Error: /work/0/startDate must match format "date"
       └─┬─┘ └┬┘ └────┬───┘
         │    │       └── What's wrong
         │    └── Array index
         └── Section path

{
  "error": "/basics/email",
  "fix": "Ensure it's a valid email: user@domain.com"
},
{
  "error": "/work/0/startDate",
  "fix": "Use ISO 8601: YYYY-MM-DD format"
},
{
  "error": "/skills/2/keywords",
  "fix": "Must be an array, not a string"
}

# Install VS Code extensions
code --install-extension esbenp.prettier-vscode
code --install-extension redhat.vscode-yaml

{
  "json.schemas": [
    {
      "fileMatch": ["resume.json"],
      "url": "https://raw.githubusercontent.com/jsonresume/resume-schema/master/schema.json"
    }
  ],
  "editor.formatOnSave": true,
  "editor.defaultFormatter": "esbenp.prettier-vscode"
}

// Add to Preferences > Settings
{
  "tab_size": 2,
  "translate_tabs_to_spaces": true,
  "detect_indentation": false
}

{
  "work": [
    {
      "startDate": "2020-01-15",
      "endDate": "2023-06-30"
    }
  ]
}

// WRONG
"startDate": "01/15/2020"
 
// CORRECT
"startDate": "2020-01-15"

// WRONG
"startDate": "15/01/2020"
 
// CORRECT
"startDate": "2020-01-15"

// WRONG
"startDate": "January 15, 2020"
 
// CORRECT
"startDate": "2020-01-15"

// WRONG
"startDate": "Jan 2020"
 
// CORRECT (first day of month)
"startDate": "2020-01-01"

{
  "work": [
    {
      "name": "Current Company",
      "startDate": "2023-01-01",
      "endDate": ""
    }
  ]
}

{
  "work": [
    {
      "name": "Company",
      "startDate": "2020-01-01",
      "endDate": "2023-01-01"
    }
  ]
}

// ISO 8601 date format: YYYY-MM-DD
const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
 
function isValidDate(dateString) {
  if (!dateRegex.test(dateString)) return false;
  const date = new Date(dateString);
  return date instanceof Date && !isNaN(date);
}

// Convert MM/DD/YYYY to ISO 8601
function toISO8601(usDate) {
  const [month, day, year] = usDate.split('/');
  return `${year}-${month.padStart(2, '0')}-${day.padStart(2, '0')}`;
}
 
console.log(toISO8601('1/15/2020')); // "2020-01-15"

# Validate JSON syntax and schema compliance
resume validate
 
# Should output:
# ✓ Your resume is valid!

# Start local server with default theme
resume serve
 
# Test with specific themes
resume serve --theme elegant
resume serve --theme professional
resume serve --theme spartacus
 
# Opens in browser at http://localhost:4000

# Export to different formats
resume export resume.html
resume export resume.pdf --theme professional
resume export resume.md
 
# Open and review each file
open resume.html
open resume.pdf
open resume.md

# Test mobile responsiveness
resume serve --theme professional
 
# Then in browser DevTools:
# - Toggle device toolbar
# - Test iPhone, iPad, Android sizes
# - Check portrait and landscape

# Generate PDF
resume export resume.pdf --theme professional
 
# Check for:
# - Page breaks in appropriate places
# - Font rendering
# - Links (should be clickable)
# - Margins and spacing
# - Print quality (print preview)

# Export to HTML
resume export resume.html
 
# Use accessibility tools:
# - WAVE browser extension
# - axe DevTools
# - Lighthouse in Chrome DevTools

☐ Name and contact info correct
☐ All dates in correct format (YYYY-MM-DD)
☐ No typos or grammar errors
☐ All URLs working and correct
☐ Email address current
☐ Phone number formatted correctly
☐ Skills listed accurately
☐ Work experience in reverse chronological order
☐ Education details correct
☐ Achievements and highlights compelling
☐ No sensitive/confidential information

const fs = require('fs');
const Ajv = require('ajv');
const schema = require('resume-schema');
 
// Load and validate
const resume = JSON.parse(fs.readFileSync('resume.json', 'utf8'));
const ajv = new Ajv();
const validate = ajv.compile(schema);
 
if (validate(resume)) {
  console.log('✓ Valid resume');
 
  // Additional checks
  if (resume.basics.email.includes('@')) {
    console.log('✓ Email format looks good');
  }
 
  if (resume.work && resume.work.length > 0) {
    console.log(`✓ ${resume.work.length} work experiences`);
  }
} else {
  console.error('✗ Validation errors:', validate.errors);
}

# Publish to private Gist first
# 1. Create secret Gist on GitHub
# 2. Test the resume URL
# 3. If good, make it public

☐ JSON validates successfully
☐ Previewed in at least 2 themes
☐ PDF export looks professional
☐ HTML export is responsive
☐ No broken links
☐ No sensitive information included
☐ Spell-checked and proofread
☐ Tested in Chrome and Safari
☐ Mobile view looks good
☐ Ready to share with recruiters

1. Load schema from:
   https://raw.githubusercontent.com/jsonresume/resume-schema/master/schema.json

2. Paste your resume JSON

3. Click "Validate"

# POST your resume to validation endpoint
curl -X POST https://jsonresume.org/api/validate \
  -H "Content-Type: application/json" \
  -d @resume.json

1. Fix JSON syntax errors (JSONLint)
   ↓
2. Validate against schema (JSON Schema Validator)
   ↓
3. Test rendering (JSONResume.org web editor)
   ↓
4. Export and review (preview themes)

# GitHub Actions example
name: Validate Resume
on: [push]
jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: actions/setup-node@v2
      - run: npm install -g resume-cli
      - run: resume validate

<!DOCTYPE html>
<html>
  <head>
    <script src="https://cdn.jsdelivr.net/npm/ajv@8/dist/ajv7.min.js"></script>
  </head>
  <body>
    <textarea id="resume" placeholder="Paste resume JSON"></textarea>
    <button onclick="validate()">Validate</button>
    <pre id="result"></pre>
 
    <script>
      async function validate() {
        const ajv = new Ajv();
        const schema = await fetch(
          'https://raw.githubusercontent.com/jsonresume/resume-schema/master/schema.json'
        ).then((r) => r.json());
 
        const resume = JSON.parse(document.getElementById('resume').value);
        const valid = ajv.validate(schema, resume);
 
        document.getElementById('result').textContent = valid
          ? '✓ Valid!'
          : JSON.stringify(ajv.errors, null, 2);
      }
    </script>
  </body>
</html>

{
  "basics": {
    "name": "José García",
    "summary": "Développeur Full-Stack specializing in 日本語"
  }
}

File → Save with Encoding → UTF-8

# Check file encoding
file -I resume.json
 
# Should output: text/plain; charset=utf-8
 
# Convert to UTF-8 if needed
iconv -f ISO-8859-1 -t UTF-8 resume.json > resume-utf8.json

{
  "basics": {
    "name": "François Müller",
    "location": {
      "city": "São Paulo"
    }
  }
}

{
  "basics": {
    "summary": "Developer who loves ☕ and 💻"
  }
}

// WRONG (smart quotes from Word)
"summary": "I'm a "full-stack" developer"
 
// CORRECT (straight quotes)
"summary": "I'm a \"full-stack\" developer"

const fs = require('fs');
let content = fs.readFileSync('resume.json', 'utf8');
 
// Replace smart quotes with straight quotes
content = content.replace(/[\u201C\u201D]/g, '"'); // Curly double quotes
content = content.replace(/[\u2018\u2019]/g, "'"); // Curly single quotes
content = content.replace(/\u2013/g, '-'); // En dash
content = content.replace(/\u2014/g, '--'); // Em dash
 
fs.writeFileSync('resume-fixed.json', content, 'utf8');

# Unix/Mac (LF)
# Windows (CRLF)
 
# Convert CRLF to LF
dos2unix resume.json
 
# Or in VS Code:
# Bottom right → "CRLF" → Select "LF"

{
  "basics": {
    "summary": "Expert in C++ and C#",
    "note": "Line 1\nLine 2\nLine 3"
  }
}

// WRONG
"summary": "Expert in <React> & Node.js"
 
// CORRECT
"summary": "Expert in React and Node.js"

const fs = require('fs');
 
// Read with explicit encoding
const resume = fs.readFileSync('resume.json', 'utf8');
 
try {
  const parsed = JSON.parse(resume);
  console.log('✓ Encoding is correct');
} catch (err) {
  console.error('✗ Encoding issue detected:', err.message);
}

☐ File saved as UTF-8 without BOM
☐ No smart quotes (use straight quotes)
☐ Special characters displaying correctly
☐ No HTML entities in text
☐ Line endings consistent (LF recommended)
☐ JSON validates without errors
☐ All text readable in multiple editors

/* Web styles */
.resume {
  font-size: 16px;
}
 
/* Print styles (PDF) */
@media print {
  .resume {
    font-size: 12px;
  }
}

{
  "theme": {
    "webFont": "Inter, sans-serif",
    "pdfFont": "Arial, sans-serif"
  }
}

/* Force page breaks in PDF */
@media print {
  .work-experience {
    page-break-inside: avoid;
  }
 
  h2 {
    page-break-after: avoid;
  }
}

/* HTML - links are blue and underlined */
a {
  color: blue;
  text-decoration: underline;
}
 
/* PDF - links may not show or may appear differently */
@media print {
  a {
    color: black;
    text-decoration: none;
  }
  a:after {
    content: ' (' attr(href) ')';
  }
}

{
  "basics": {
    "image": "https://example.com/photo.jpg"
  }
}

/* HTML adapts to viewport */
@media (max-width: 768px) {
  .resume {
    font-size: 14px;
  }
}
 
/* PDF is fixed at A4/Letter size */
@media print {
  @page {
    size: A4;
  }
}

/* May not print by default */
@media print {
  .section {
    background-color: #f0f0f0; /* May be removed */
    border: 1px solid #ccc; /* May not print */
  }
}

# Generate both
resume export resume.html --theme professional
resume export resume.pdf --theme professional
 
# Compare side by side
open resume.html
open resume.pdf

# Themes designed for PDF export
resume export resume.pdf --theme elegant
resume export resume.pdf --theme kendall
resume export resume.pdf --theme professional

/* Custom print stylesheet */
@media print {
  /* Match web styles */
  body {
    font-size: 11pt;
  }
  h1 {
    font-size: 18pt;
  }
  h2 {
    font-size: 14pt;
  }
 
  /* Page setup */
  @page {
    size: A4;
    margin: 2cm;
  }
 
  /* Avoid orphans/widows */
  p,
  li {
    orphans: 3;
    widows: 3;
  }
}

# Use browser to print HTML to PDF
# This ensures perfect consistency
 
# Or use command line
wkhtmltopdf resume.html resume.pdf

1. Open HTML in browser
2. Open Print Preview (Cmd+P / Ctrl+P)
3. Compare with generated PDF
4. Adjust print styles
5. Regenerate PDF
6. Repeat until consistent

{
  "basics": {
    "name": "Your Name"
  }
}

// WRONG - will fail validation
{
  "work": [...],
  "education": [...]
}
 
// CORRECT - basics is present
{
  "basics": {
    "name": "Your Name"
  },
  "work": [...],
  "education": [...]
}

// WRONG - basics exists but empty
{
  "basics": {}
}
 
// CORRECT - at minimum, include name
{
  "basics": {
    "name": "Your Name"
  }
}

// WRONG - typo
{
  "basic": {
    "name": "Your Name"
  }
}
 
// CORRECT
{
  "basics": {
    "name": "Your Name"
  }
}

// WRONG - wrong case
{
  "Basics": {
    "name": "Your Name"
  }
}
 
// CORRECT - lowercase
{
  "basics": {
    "name": "Your Name"
  }
}

{
  "basics": {
    "name": "John Doe",
    "label": "Software Engineer",
    "image": "",
    "email": "john@example.com",
    "phone": "(555) 123-4567",
    "url": "https://johndoe.com",
    "summary": "Experienced software engineer...",
    "location": {
      "address": "",
      "postalCode": "",
      "city": "San Francisco",
      "countryCode": "US",
      "region": "California"
    },
    "profiles": [
      {
        "network": "GitHub",
        "username": "johndoe",
        "url": "https://github.com/johndoe"
      }
    ]
  }
}

function validateBasics(resume) {
  if (!resume.basics) {
    return { valid: false, error: 'Missing basics section' };
  }
 
  if (!resume.basics.name) {
    return { valid: false, error: 'Missing name in basics' };
  }
 
  return { valid: true };
}
 
// Usage
const result = validateBasics(myResume);
if (!result.valid) {
  console.error(result.error);
}

{
  "basics": {
    "name": "Your Full Name",
    "label": "Your Job Title",
    "email": "your.email@example.com",
    "summary": "Brief professional summary"
  }
 
  // ... rest of your resume
}

{
  "name": "Resume data in JSON"
}

{
  "basics": {
    "name": "John Doe",
    "email": "john@example.com"
  }
}

basics:
  name: John Doe
  email: john@example.com

<resume>
  <basics>
    <name>John Doe</name>
    <email>john@example.com</email>
  </basics>
</resume>

// Native JSON support in all environments
const resume = JSON.parse(data);
const string = JSON.stringify(resume);

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["basics"],
  "properties": {
    "basics": { "type": "object" }
  }
}

# Fetch resume via API
curl https://jsonresume.org/api/resume/username
 
# Returns JSON - no conversion needed

-- PostgreSQL
SELECT basics->>'name' FROM resumes;
 
-- MongoDB
db.resumes.find({ "basics.name": "John Doe" });

# Is this a boolean or string?
no: no
 
# Requires quotes to clarify
no: "no"

<work>
  <item>
    <name>Company</name>
    <position>Developer</position>
  </item>
</work>

{
  "work": [
    {
      "name": "Company",
      "position": "Developer"
    }
  ]
}

// JSON to YAML
const YAML = require('yaml');
const resume = require('./resume.json');
const yamlResume = YAML.stringify(resume);

// JSON to XML
const { create } = require('xmlbuilder2');
const resume = require('./resume.json');
const xml = create(resume).end({ prettyPrint: true });

JSON (source of truth)
  ↓
YAML (for readability)
XML (for legacy systems)
CSV (for spreadsheets)

import schema from 'resume-schema';
import Ajv from 'ajv';
 
class ResumeBuilder {
  constructor() {
    this.ajv = new Ajv();
    this.validate = this.ajv.compile(schema);
  }
 
  createResume(data) {
    if (this.validate(data)) {
      return this.save(data);
    } else {
      throw new Error(this.validate.errors);
    }
  }
}

// Accept JSON Resume from candidates
app.post('/api/apply', async (req, res) => {
  const resume = req.body;
 
  // Validate against JSON Resume schema
  if (validateSchema(resume)) {
    // Parse and store in your database
    await db.candidates.insert({
      name: resume.basics.name,
      email: resume.basics.email,
      skills: resume.skills.map((s) => s.name),
      rawResume: resume,
    });
 
    res.json({ success: true });
  }
});

// Generate portfolio from JSON Resume
function generatePortfolio(resume) {
  return `
    <h1>${resume.basics.name}</h1>
    <p>${resume.basics.summary}</p>
 
    <h2>Projects</h2>
    ${resume.projects
      .map(
        (p) => `
      <article>
        <h3>${p.name}</h3>
        <p>${p.description}</p>
      </article>
    `
      )
      .join('')}
  `;
}

// Search candidates by skills
const candidates = await db.resumes.find({
  'skills.keywords': { $in: ['React', 'Node.js'] },
});
 
// Rank by experience
candidates.sort((a, b) => {
  const yearsA = calculateYears(a.work);
  const yearsB = calculateYears(b.work);
  return yearsB - yearsA;
});

// Import employee data from JSON Resume
async function importEmployee(resumeUrl) {
  const response = await fetch(resumeUrl);
  const resume = await response.json();
 
  return {
    employeeId: generateId(),
    fullName: resume.basics.name,
    email: resume.basics.email,
    phone: resume.basics.phone,
    position: resume.work[0].position,
    startDate: new Date(),
    skills: resume.skills.flatMap((s) => s.keywords),
  };
}

// 1. Install dependencies
npm install resume-schema ajv
 
// 2. Set up validation
import schema from 'resume-schema';
import Ajv from 'ajv';
 
const ajv = new Ajv();
const validate = ajv.compile(schema);
 
// 3. Validate incoming data
function validateResume(data) {
  if (validate(data)) {
    return { valid: true, data };
  } else {
    return { valid: false, errors: validate.errors };
  }
}
 
// 4. Store in your database
async function saveResume(resume) {
  return await db.resumes.insert({
    userId: getCurrentUserId(),
    data: resume,
    createdAt: new Date(),
    updatedAt: new Date()
  });
}
 
// 5. Retrieve and use
async function getResume(userId) {
  const record = await db.resumes.findOne({ userId });
  return record.data; // JSON Resume format
}

{
  "basics": {
    "name": "John Doe"
  },
  "work": [...],
 
  "custom": {
    "internalId": "EMP-12345",
    "department": "Engineering",
    "salary": {
      "amount": 100000,
      "currency": "USD"
    },
    "startDate": "2023-01-01"
  }
}

import { ResumeSchema } from 'resume-schema';
 
interface ExtendedResume extends ResumeSchema {
  custom?: {
    internalId: string;
    department: string;
    // ... your custom fields
  };
}
 
const resume: ExtendedResume = {
  basics: {
    name: 'John Doe',
  },
  custom: {
    internalId: 'EMP-12345',
    department: 'Engineering',
  },
};

const mapping = {
  // JSON Resume → Europass
  'basics.name': 'PersonName',
  'basics.email': 'ContactInfo.Email',
  'basics.phone': 'ContactInfo.Telephone',
  'basics.location': 'ContactInfo.Address',
  work: 'WorkExperience',
  education: 'Education',
  skills: 'Skills',
  languages: 'MotherTongue / ForeignLanguage',
};

function toEuropass(jsonResume) {
  return {
    PersonName: {
      FirstName: jsonResume.basics.name.split(' ')[0],
      Surname: jsonResume.basics.name.split(' ').slice(1).join(' '),
    },
    ContactInfo: {
      Email: jsonResume.basics.email,
      Telephone: jsonResume.basics.phone,
      Address: {
        Municipality: jsonResume.basics.location.city,
        Country: jsonResume.basics.location.countryCode,
      },
    },
    WorkExperience: jsonResume.work.map((job) => ({
      Period: {
        From: { Year: job.startDate.split('-')[0] },
        To: { Year: job.endDate?.split('-')[0] },
      },
      Position: { Label: job.position },
      Activities: job.summary,
      Employer: {
        Name: job.name,
      },
    })),
    Education: jsonResume.education.map((edu) => ({
      Period: {
        From: { Year: edu.startDate?.split('-')[0] },
        To: { Year: edu.endDate?.split('-')[0] },
      },
      Title: edu.studyType + ' in ' + edu.area,
      Organisation: {
        Name: edu.institution,
      },
    })),
  };
}

# Using a conversion library (hypothetical)
npm install europass-converter
 
# Convert
const { toEuropass } = require('europass-converter');
const europassXML = toEuropass(jsonResume);

{
  "basics": {
    "name": "John Michael Doe"
  }
}

<FirstName>John</FirstName>
<Surname>Doe</Surname>

{
  "languages": [
    {
      "language": "English",
      "fluency": "Native speaker"
    }
  ]
}

<ForeignLanguage>
  <Description>English</Description>
  <ProficiencyLevel>C2</ProficiencyLevel>
</ForeignLanguage>

const fluencyMap = {
  'Native speaker': 'C2',
  Fluent: 'C1',
  Proficient: 'B2',
  Intermediate: 'B1',
  Basic: 'A2',
  Beginner: 'A1',
};

{
  "skills": [
    {
      "name": "Web Development",
      "keywords": ["HTML", "CSS", "JavaScript"]
    }
  ]
}

1. Maintain resume in JSON Resume format
2. Use JSON Resume tools and themes
3. Convert to Europass only when applying to EU jobs
4. Submit Europass XML to systems that require it

// Keep both formats in sync
const resume = {
  jsonResume: {
    /* JSON Resume data */
  },
  europass: convertToEuropass(jsonResume),
};
 
// Export as needed
function exportForEU() {
  return resume.europass;
}
 
function exportForUS() {
  return resume.jsonResume;
}

{
  "@context": "https://schema.org",
  "@type": "Person",
  "name": "John Doe",
  "jobTitle": "Software Engineer",
  "worksFor": {
    "@type": "Organization",
    "name": "Tech Company"
  }
}

{
  "basics": {
    "name": "John Doe",
    "label": "Software Engineer"
  },
  "work": [
    {
      "name": "Tech Company",
      "position": "Software Engineer"
    }
  ]
}

<!-- Embedded in HTML for SEO -->
<script type="application/ld+json">
  {
    "@context": "https://schema.org",
    "@type": "Person",
    "name": "John Doe",
    "url": "https://johndoe.com",
    "sameAs": [
      "https://www.linkedin.com/in/johndoe",
      "https://github.com/johndoe"
    ]
  }
</script>

<Resume>
  <StructuredXMLResume>
    <ContactInfo>
      <PersonName>
        <GivenName>John</GivenName>
        <FamilyName>Doe</FamilyName>
      </PersonName>
    </ContactInfo>
    <EmploymentHistory>
      <EmployerOrg>
        <EmployerOrgName>Tech Corp</EmployerOrgName>
      </EmployerOrg>
    </EmploymentHistory>
  </StructuredXMLResume>
</Resume>

{
  "basics": { "name": "John Doe" },
  "work": [],
  "education": []
}

// Easy to work with
const resume = require('./resume.json');
console.log(resume.basics.name);

// Convert JSON Resume to Schema.org
function toSchemaOrg(resume) {
  return {
    '@context': 'https://schema.org',
    '@type': 'Person',
    name: resume.basics.name,
    email: resume.basics.email,
    url: resume.basics.url,
    jobTitle: resume.basics.label,
    alumniOf: resume.education.map((edu) => ({
      '@type': 'EducationalOrganization',
      name: edu.institution,
    })),
    worksFor: resume.work[0] && {
      '@type': 'Organization',
      name: resume.work[0].name,
    },
  };
}

JSON Resume (source of truth)
    ↓
    ├→ Schema.org (for SEO)
    ├→ HR-XML (for ATS)
    ├→ Europass (for EU)
    └→ LinkedIn (for networking)

{
  "$schema": "https://json-schema.org/draft-07/schema#",
  "title": "Resume Schema",
  "type": "object",
  "additionalProperties": false,
  "properties": {
    "basics": { "$ref": "#/definitions/basics" },
    "work": { "$ref": "#/definitions/work" },
    "volunteer": { "$ref": "#/definitions/volunteer" },
    "education": { "$ref": "#/definitions/education" },
    "awards": { "$ref": "#/definitions/awards" },
    "certificates": { "$ref": "#/definitions/certificates" },
    "publications": { "$ref": "#/definitions/publications" },
    "skills": { "$ref": "#/definitions/skills" },
    "languages": { "$ref": "#/definitions/languages" },
    "interests": { "$ref": "#/definitions/interests" },
    "references": { "$ref": "#/definitions/references" },
    "projects": { "$ref": "#/definitions/projects" }
  },
  "required": ["basics"]
}

resume
├── basics (personal information)
├── work (employment history)
├── volunteer (volunteer experience)
├── education (academic background)
├── awards (honors and awards)
├── certificates (professional certifications)
├── publications (published works)
├── skills (technical and soft skills)
├── languages (language proficiency)
├── interests (personal interests)
├── references (professional references)
└── projects (portfolio projects)

{
  "basics": {
    "name": "string",           // Required
    "label": "string",          // Professional title
    "image": "uri",             // Profile photo
    "email": "email",           // Contact email
    "phone": "string",          // Phone number
    "url": "uri",               // Personal website
    "summary": "string",        // Professional summary
    "location": "object",       // Geo location
    "profiles": "array<object>" // Social profiles
  }
}

const schemaOrgMapping = {
  'basics.name': 'Person.name',
  'basics.email': 'Person.email',
  'basics.url': 'Person.url',
  'basics.label': 'Person.jobTitle',
  'basics.summary': 'Person.description',
  'basics.profiles': 'Person.sameAs',
  work: 'Person.worksFor / Person.alumniOf',
  education: 'Person.alumniOf',
  skills: 'Person.knowsAbout',
};

const vCardMapping = {
  'basics.name': 'FN',
  'basics.email': 'EMAIL',
  'basics.phone': 'TEL',
  'basics.url': 'URL',
  'basics.location.city': 'ADR;LOCALITY',
  'basics.location.countryCode': 'ADR;COUNTRY',
};

const linkedInMapping = {
  'basics.name': 'firstName + lastName',
  'basics.label': 'headline',
  'basics.summary': 'summary',
  'basics.location': 'location',
  'basics.profiles': 'contactInfo',
  work: 'positions',
  education: 'educations',
  skills: 'skills',
  volunteer: 'volunteer',
};

{
  "definitions": {
    "iso8601": {
      "type": "string",
      "pattern": "^([0-9]{4})-([0-9]{2})-([0-9]{2})$"
    },
    "email": {
      "type": "string",
      "format": "email"
    },
    "uri": {
      "type": "string",
      "format": "uri"
    }
  }
}

{
  "basics": "1",        // Exactly one (required)
  "work": "0..*",       // Zero or more
  "education": "0..*",  // Zero or more
  "skills": "0..*",     // Zero or more
  "languages": "0..*",  // Zero or more
  "projects": "0..*"    // Zero or more
}

{
  "work": {
    "required": ["name", "position", "startDate"],
    "optional": ["url", "endDate", "summary", "highlights"]
  },
  "education": {
    "required": ["institution", "area", "studyType"],
    "optional": ["url", "startDate", "endDate", "score", "courses"]
  }
}

Person (basics)
  ├─ worksAt ────> Organization (work)
  ├─ attendedSchool ─> EducationalInstitution (education)
  ├─ hasSkill ────> Skill (skills)
  ├─ speaks ─────> Language (languages)
  ├─ created ────> CreativeWork (projects, publications)
  ├─ volunteeredAt > Organization (volunteer)
  └─ received ───> Award (awards)

// Find all React developers
const reactDevs = resumes.filter((r) =>
  r.skills.some((s) => s.keywords.includes('React'))
);
 
// Find people in San Francisco
const sfResidents = resumes.filter(
  (r) => r.basics.location.city === 'San Francisco'
);
 
// Find recent graduates (< 2 years)
const graduates = resumes.filter((r) =>
  r.education.some((e) => {
    const year = new Date(e.endDate).getFullYear();
    return year >= new Date().getFullYear() - 2;
  })
);

@prefix jr: <https://jsonresume.org/schema/> .
@prefix foaf: <http://xmlns.com/foaf/0.1/> .
 
:person1 a jr:Person ;
  foaf:name "John Doe" ;
  jr:label "Software Engineer" ;
  jr:email "john@example.com" ;
  jr:hasSkill :skill1 .
 
:skill1 a jr:Skill ;
  jr:name "JavaScript" ;
  jr:level "Advanced" .

type Resume {
  basics: Basics!
  work: [Work!]
  education: [Education!]
  skills: [Skill!]
  projects: [Project!]
}
 
type Basics {
  name: String!
  label: String
  email: String
  phone: String
  url: String
  summary: String
  location: Location
  profiles: [Profile!]
}
 
type Work {
  name: String!
  position: String!
  url: String
  startDate: Date!
  endDate: Date
  summary: String
  highlights: [String!]
}

{
  "basics": {
    "name": "John Doe"
  },
 
  "meta": {
    "canonical": "https://jsonresume.org/schema/v1",
    "version": "1.0.0",
    "lastModified": "2024-01-01T00:00:00Z"
  },
 
  "custom": {
    "internalId": "12345",
    "department": "Engineering"
  }
}

{
  "basics": {
    "name": "Engineering Team"
  },
 
  "orgChart": {
    "employees": [
      {
        "name": "Jane Smith",
        "position": "Engineering Manager",
        "email": "jane@company.com",
        "reportsTo": null,
        "team": "Engineering",
        "resume": "./jane-resume.json"
      },
      {
        "name": "John Doe",
        "position": "Senior Engineer",
        "email": "john@company.com",
        "reportsTo": "jane@company.com",
        "team": "Engineering",
        "resume": "./john-resume.json"
      }
    ],
    "teams": [
      {
        "name": "Engineering",
        "manager": "jane@company.com",
        "members": ["john@company.com", "alice@company.com"]
      }
    ]
  }
}

{
  "company": {
    "name": "Tech Corp",
    "ceo": {
      "name": "CEO Name",
      "resume": "ceo-resume.json",
      "directReports": [
        {
          "name": "CTO",
          "resume": "cto-resume.json",
          "directReports": [
            {
              "name": "Engineering Manager",
              "resume": "em-resume.json",
              "directReports": [
                {
                  "name": "Senior Engineer",
                  "resume": "se-resume.json"
                }
              ]
            }
          ]
        }
      ]
    }
  }
}

{
  "team": {
    "name": "Engineering",
    "members": [
      {
        "resumeUrl": "https://jsonresume.org/alice",
        "role": "Tech Lead",
        "joinDate": "2020-01-01",
        "skills": ["React", "Node.js"]
      },
      {
        "resumeUrl": "https://jsonresume.org/bob",
        "role": "Senior Engineer",
        "joinDate": "2021-06-01",
        "skills": ["Python", "Machine Learning"]
      }
    ]
  }
}

async function buildOrgChart(teamData) {
  const members = await Promise.all(
    teamData.members.map(async (member) => {
      const response = await fetch(member.resumeUrl);
      const resume = await response.json();
 
      return {
        name: resume.basics.name,
        role: member.role,
        email: resume.basics.email,
        skills: resume.skills.flatMap((s) => s.keywords),
        experience: calculateYears(resume.work),
        image: resume.basics.image,
      };
    })
  );
 
  return {
    teamName: teamData.name,
    size: members.length,
    members,
    skillsMatrix: aggregateSkills(members),
  };
}

function aggregateSkills(members) {
  const allSkills = {};
 
  members.forEach((member) => {
    member.skills.forEach((skill) => {
      allSkills[skill] = (allSkills[skill] || 0) + 1;
    });
  });
 
  return Object.entries(allSkills)
    .map(([skill, count]) => ({ skill, count }))
    .sort((a, b) => b.count - a.count);
}
 
// Result:
// [
//   { skill: 'JavaScript', count: 8 },
//   { skill: 'React', count: 6 },
//   { skill: 'Node.js', count: 5 }
// ]

{
  "departments": [
    {
      "name": "Engineering",
      "head": "cto-resume.json",
      "teams": [
        {
          "name": "Frontend",
          "lead": "frontend-lead-resume.json",
          "members": ["engineer1-resume.json", "engineer2-resume.json"]
        },
        {
          "name": "Backend",
          "lead": "backend-lead-resume.json",
          "members": ["engineer3-resume.json", "engineer4-resume.json"]
        }
      ]
    }
  ]
}

import OrgChart from 'd3-org-chart';
 
function renderOrgChart(data) {
  const chart = new OrgChart()
    .container('.org-chart')
    .data(data)
    .nodeContent(
      (d) => `
      <div class="node">
        <img src="${d.data.image}" />
        <div>${d.data.name}</div>
        <div>${d.data.position}</div>
      </div>
    `
    );
 
  chart.render();
}

{
  "companyDirectory": {
    "name": "Tech Corp Directory",
    "employees": [
      {
        "id": "emp001",
        "resume": "https://jsonresume.org/alice",
        "department": "Engineering",
        "location": "San Francisco",
        "startDate": "2020-01-01"
      }
    ],
    "searchable": true,
    "filters": ["department", "location", "skills"]
  }
}

class CompanyOrgChart {
  constructor(employees) {
    this.employees = employees;
  }
 
  async loadResumes() {
    this.resumes = await Promise.all(
      this.employees.map((e) => fetch(e.resumeUrl).then((r) => r.json()))
    );
  }
 
  getBySkill(skill) {
    return this.resumes.filter((r) =>
      r.skills.some((s) => s.keywords.includes(skill))
    );
  }
 
  getByDepartment(dept) {
    return this.employees.filter((e) => e.department === dept);
  }
 
  buildHierarchy() {
    // Build org chart from reportsTo relationships
    const nodes = this.employees.map((e) => ({
      id: e.id,
      name: e.name,
      parentId: e.reportsTo,
    }));
 
    return buildTree(nodes);
  }
}

{
  "basics": {
    "name": "Jane Designer",
    "label": "Product Designer",
    "url": "https://janedesigner.com"
  },
 
  "projects": [
    {
      "name": "E-commerce Redesign",
      "description": "Complete redesign of a major e-commerce platform",
      "highlights": [
        "Increased conversion rate by 35%",
        "Improved mobile experience",
        "Reduced cart abandonment by 20%"
      ],
      "keywords": ["UI/UX", "Figma", "User Research"],
      "startDate": "2023-01-01",
      "endDate": "2023-06-30",
      "url": "https://janedesigner.com/projects/ecommerce",
      "roles": ["Lead Designer", "User Researcher"],
      "entity": "Client Name",
      "type": "Client Work"
    },
    {
      "name": "Open Source Design System",
      "description": "Created a comprehensive design system for React applications",
      "highlights": [
        "50+ reusable components",
        "Full documentation",
        "1000+ GitHub stars"
      ],
      "keywords": ["Design System", "React", "Storybook"],
      "startDate": "2022-01-01",
      "endDate": "",
      "url": "https://github.com/jane/design-system",
      "roles": ["Creator", "Maintainer"],
      "type": "Open Source"
    }
  ]
}

{
  "projects": [
    {
      "name": "Mobile App Redesign",
      "description": "Complete redesign of fitness tracking app",
 
      "caseStudy": {
        "problem": "Users struggled with complex navigation and low engagement",
        "solution": "Simplified UI with focus on quick logging and streaks",
        "process": [
          "User interviews (20 participants)",
          "Competitive analysis",
          "Wireframing and prototyping",
          "A/B testing",
          "Iteration based on feedback"
        ],
        "results": {
          "engagement": "+45%",
          "retention": "+30%",
          "nps": "+25 points"
        },
        "visuals": [
          "https://portfolio.com/images/before-after.jpg",
          "https://portfolio.com/images/wireframes.jpg",
          "https://portfolio.com/images/final-design.jpg"
        ],
        "testimonial": {
          "quote": "Jane transformed our app and doubled our user retention",
          "author": "CEO, Fitness App Inc."
        }
      },
 
      "keywords": ["Mobile", "UI/UX", "User Research"],
      "url": "https://portfolio.com/case-studies/fitness-app",
      "startDate": "2023-03-01",
      "endDate": "2023-09-01"
    }
  ]
}

{
  "projects": [
    {
      "name": "Real-time Chat Application",
      "description": "Slack-like chat with channels, DMs, and file sharing",
      "highlights": [
        "Built with Next.js and Socket.io",
        "1000+ concurrent users",
        "End-to-end encryption"
      ],
      "keywords": ["Next.js", "Socket.io", "PostgreSQL", "Redis"],
      "url": "https://github.com/user/chat-app",
      "roles": ["Full-stack Developer"],
      "type": "Personal Project",
 
      "technicalDetails": {
        "stack": {
          "frontend": "Next.js, React, TailwindCSS",
          "backend": "Node.js, Express, Socket.io",
          "database": "PostgreSQL, Redis",
          "deployment": "Vercel, Railway"
        },
        "features": [
          "Real-time messaging",
          "File uploads",
          "User presence",
          "Message search",
          "Push notifications"
        ],
        "challenges": [
          {
            "problem": "Scaling WebSocket connections",
            "solution": "Implemented Redis pub/sub for horizontal scaling"
          }
        ]
      }
    }
  ]
}

{
  "publications": [
    {
      "name": "The Future of Remote Work",
      "publisher": "Tech Magazine",
      "releaseDate": "2023-06-15",
      "url": "https://techmagazine.com/future-remote-work",
      "summary": "Analysis of remote work trends and predictions for the next decade",
 
      "portfolio": {
        "category": "Thought Leadership",
        "wordCount": 2500,
        "readTime": "10 minutes",
        "metrics": {
          "views": "50000+",
          "shares": 1200,
          "comments": 340
        },
        "awards": ["Editor's Choice", "Most Shared Article 2023"]
      }
    }
  ]
}

{
  "projects": [
    {
      "name": "Urban Landscapes Series",
      "description": "Photo series exploring modern architecture",
      "type": "Photography",
 
      "creative": {
        "medium": "Digital Photography",
        "equipment": "Sony A7III, 24-70mm f/2.8",
        "techniques": ["Long exposure", "HDR", "Bracketing"],
        "exhibitions": [
          {
            "name": "Modern Cities",
            "venue": "Art Gallery NYC",
            "date": "2023-05-01",
            "url": "https://artgallery.com/exhibitions/modern-cities"
          }
        ],
        "gallery": [
          "https://portfolio.com/urban1.jpg",
          "https://portfolio.com/urban2.jpg"
        ],
        "press": [
          {
            "title": "Rising Star in Urban Photography",
            "publication": "Photo Magazine",
            "url": "https://photomag.com/rising-star"
          }
        ]
      },
 
      "keywords": ["Photography", "Architecture", "Urban"],
      "url": "https://portfolio.com/urban-series",
      "startDate": "2022-01-01",
      "endDate": "2023-12-31"
    }
  ]
}