Job Posting Free Text to Structured Requisition Prompt Template

This prompt is designed for recruiting platform engineers and integration developers who need to convert unstructured job descriptions—pasted from emails, web pages, or documents—into clean, typed requisition records. The core job is to extract and normalize fields like title, location, salary range, responsibilities, and qualifications from messy free text, producing a JSON object that can be ingested by an applicant tracking system (ATS) or job board API. The ideal user is building a data pipeline where human-readable job posts must become machine-readable records without manual data entry.

Use this prompt when the input is a single, self-contained job description in plain text or markdown. It is designed for cases where the model failed to produce structured output in the first pass, or where you are processing legacy text that was never structured. The prompt template includes placeholders for the raw input text, a target output schema, and constraints like required-vs-preferred classification for qualifications. It is not suitable for batch processing of hundreds of job descriptions in a single call, for extracting requisitions from multi-job career pages, or for parsing non-English text without adapting the schema and instructions. Do not use this prompt where the extracted data will directly trigger automated hiring decisions without human review.

Before wiring this into production, define your output schema precisely and prepare a golden dataset of 20-50 job descriptions with known correct extractions. Run the prompt against this dataset and measure field-level accuracy, especially for skill extraction and salary range normalization. Pay close attention to failure modes like hallucinated qualifications, misclassified required-vs-preferred skills, and salary ranges parsed from the wrong currency or pay period. The next section provides the copy-ready template you can adapt with your own schema and validation rules.

This prompt template transforms unstructured job posting text into a machine-readable requisition record. It is designed for recruiting platform engineers who need to ingest free-text job descriptions from emails, career sites, or hiring manager notes and produce a consistent JSON payload for downstream ATS, CRM, or approval workflows. The template uses square-bracket placeholders that you replace with your actual input, output schema, constraints, and examples before sending to the model.

textCopy
You are a recruiting data extraction system. Your task is to convert the following free-text job posting into a structured requisition record.

## INPUT
[INPUT]

## OUTPUT SCHEMA
Return ONLY valid JSON matching this schema:
{
  "title": "string (normalized job title)",
  "department": "string | null",
  "location": {
    "city": "string | null",
    "state": "string | null",
    "country": "string | null",
    "remote": "boolean",
    "hybrid": "boolean"
  },
  "employment_type": "string (enum: full-time, part-time, contract, internship, temporary)",
  "salary_range": {
    "min": "number | null",
    "max": "number | null",
    "currency": "string | null",
    "period": "string | null (enum: hourly, monthly, annual)"
  },
  "requirements": [
    {
      "skill": "string",
      "classification": "string (enum: required, preferred, nice-to-have)",
      "years_experience": "number | null"
    }
  ],
  "responsibilities": ["string"],
  "qualifications": {
    "education": "string | null",
    "certifications": ["string"],
    "clearance": "string | null"
  },
  "benefits": ["string"],
  "posting_date": "string (ISO 8601 date) | null",
  "closing_date": "string (ISO 8601 date) | null",
  "contact_email": "string | null",
  "company_name": "string | null",
  "extraction_confidence": "number (0.0 to 1.0)",
  "missing_fields": ["string (field names that could not be extracted)"],
  "ambiguous_phrases": ["string (phrases that had multiple interpretations)"]
}

## CONSTRAINTS
[CONSTRAINTS]

## EXAMPLES
[EXAMPLES]

## INSTRUCTIONS
1. Extract every field that is explicitly stated in the input.
2. Set fields to null or empty arrays when no information is available—do not invent values.
3. Classify each requirement as "required," "preferred," or "nice-to-have" based on language cues (e.g., "must have" = required, "bonus" = nice-to-have).
4. Normalize job titles to industry-standard forms (e.g., "Sr. SWE" → "Senior Software Engineer").
5. Parse salary ranges even when formatted inconsistently (e.g., "$80-100k" or "80,000 to 100,000 per year").
6. Set extraction_confidence based on how much of the schema you could populate from explicit text (1.0 = all fields populated from text, 0.0 = no fields populated).
7. List any fields you could not populate in missing_fields.
8. List any phrases where you were uncertain about interpretation in ambiguous_phrases.
9. Return ONLY the JSON object. No markdown, no explanation.

To adapt this template, replace [INPUT] with the raw job posting text, [CONSTRAINTS] with any domain-specific rules (e.g., "only accept US-based roles" or "require salary transparency"), and [EXAMPLES] with one or two input-output pairs that demonstrate correct extraction and classification behavior. The examples are critical for teaching the model how to distinguish required from preferred skills and how to handle edge cases like equity-only compensation or multi-location roles. If you are processing job postings in a regulated industry or where hiring decisions have legal implications, add a human review step before the structured record enters any downstream system of record.

This prompt is designed to be called as a post-processing step in a recruiting pipeline, not as a standalone chat interface. The typical integration pattern is: an upstream system (ATS, email parser, or career site scraper) ingests the free-text job description, passes it to this prompt via an API call, and the structured output is validated before being written to the requisition database. Because the prompt handles unstructured-to-structured conversion, it should be treated as a data transformation step with the same rigor as an ETL job—including schema validation, error handling, and observability.

Validation and Retry Logic: The prompt output must pass a JSON schema validator before being accepted. Key checks include: required fields present (title, requirements, responsibilities), salary_range conforming to {min, max, currency} shape, and qualifications correctly split into required and preferred arrays. If validation fails, implement a single retry by appending the validation error to the prompt as [PREVIOUS_ERRORS] and re-running. Do not retry more than twice—after two failures, route the job posting to a human review queue with the original text and both failed attempts attached. This prevents infinite loops on genuinely ambiguous or malformed inputs.

Model Choice and Latency: For this task, prefer models with strong instruction-following and JSON mode support (e.g., GPT-4o, Claude 3.5 Sonnet). Enable structured output mode if the provider supports it, as this dramatically reduces malformed JSON rates. Set a timeout of 15 seconds for the API call; if the model exceeds this, fall back to a faster model (e.g., GPT-4o-mini) for the retry. Log every conversion attempt with the input hash, model used, latency, and validation result. This trace data is essential for debugging extraction quality over time and identifying job descriptions that consistently break the pipeline.

Human-in-the-Loop Integration: Even when validation passes, flag outputs for human review if the model's confidence indicators are low—specifically, if [CONFIDENCE_FLAGS] in the output contains warnings about ambiguous skill classification or conflicting requirements. Build a simple review UI that shows the original free text side-by-side with the structured record, highlighting fields that were flagged. This is not optional for regulated industries or roles with compliance requirements (e.g., healthcare, finance). The prompt template includes a [RISK_LEVEL] parameter; when set to high, the harness should enforce mandatory human approval before the record enters the requisition database.

Next Steps: After integrating this prompt, run a batch evaluation against 50–100 historical job postings with known-good structured records. Measure field-level accuracy (especially skill extraction and required-vs-preferred classification) and track the retry rate. Use these metrics to tune the prompt's few-shot examples and field descriptions. Avoid the temptation to add more fields to the output schema without updating the eval harness—every new field is a new failure mode.