Procurement and operations teams

From Purchase Order PDFs to Structured Data: An Example Workflow

This practical example shows how a procurement or operations team can define a purchase order schema, extract fields from PDFs and other supported inputs, review exceptions, validate totals, and return structured JSON for downstream workflows.

Short answer

Purchase order data extraction turns information trapped in purchase order documents into consistent fields that procurement and operations teams can review and use. A practical workflow begins with a defined schema covering the purchase order number, supplier, buyer, dates, currency, line items, subtotal, tax, shipping, and total. Documents are uploaded directly or received as supported inbound email attachments. ParseBuddy extracts the requested fields, users review values that need attention, and completed results can be returned as structured JSON or sent through an outbound webhook. The key is to define the expected structure before processing documents and to keep document extraction separate from business approval. Extraction captures what the purchase order says; validation rules and team review determine whether the data is complete, internally consistent, and ready for the next procurement step.

What you will learn

  • Define the extraction schema before processing purchase orders so the output remains consistent across document layouts.
  • Capture line items as a repeatable array rather than flattening them into numbered fields.
  • Keep issue dates, requested delivery dates, and other date types in separate fields.
  • Validate arithmetic, currency, required fields, and duplicate purchase order numbers after extraction.
  • Route fields that need attention to a reviewer instead of silently guessing or replacing document values.
  • Return approved data as structured JSON or send completed results through an outbound webhook.
  • Treat data capture and purchase approval as separate controls.

What purchase order data extraction should capture

Purchase orders often contain several kinds of information in one document: parties, references, dates, delivery instructions, line items, commercial terms, and totals. Capturing only the purchase order number and grand total may help with basic indexing, but it leaves procurement teams unable to analyze quantities, products, prices, or expected delivery dates.

A useful extraction schema should reflect the decisions the team needs to make after the document is processed. If the next step is order tracking, the requested delivery date and line-item quantities may be essential. If the data will support spend reporting, normalized supplier names, currency, item categories, and totals may matter more.

Start with fields that are explicitly printed in the document. Avoid asking the extraction workflow to infer approval status, supplier risk, budget availability, or whether an order should be accepted. Those are business decisions that require separate rules or human judgment.

  • Document identifiers: purchase order number and revision number
  • Parties: supplier name and buyer organization
  • Dates: issue date and requested delivery date
  • Commercial details: currency and payment terms
  • Line items: item code, description, quantity, unit, unit price, and line total
  • Summary amounts: subtotal, discount, shipping, tax, and grand total
  • Optional references: contract number, requisition number, cost center, or delivery location

Design the schema before processing documents

A schema defines the names, data types, and structure of the fields to be captured. This gives every processed purchase order a predictable output, even when suppliers use different visual layouts. One supplier may place its name in a header, while another may show it beside a logo or under a vendor label. The output field can still be called supplier_name.

Use clear field names that describe the document value rather than its visual position. Names such as top_right_date or second_total are fragile because layouts vary. Names such as issue_date, tax_amount, and grand_total express the meaning of the data.

Choose data types deliberately. Dates should use one agreed format, such as YYYY-MM-DD. Monetary amounts should be numeric and paired with a separate currency field. Quantities may need decimal values if the organization purchases materials by weight or length. Optional values should be allowed to remain null when they are not present.

Line items should be represented as an array of objects. Avoid fields such as item_1_description and item_2_description because purchase orders can contain an unpredictable number of rows. A repeatable line-item structure is easier to validate and consume downstream.

  • Use stable, descriptive field names.
  • Define required and optional fields.
  • Separate currency codes from monetary amounts.
  • Store line items in an array.
  • Allow null for genuinely absent values.
  • Document how dates, decimals, and negative amounts should be represented.

Choose how purchase orders enter the workflow

ParseBuddy turns uploaded documents and supported email attachments into structured data. Supported workflows include PDFs, images, spreadsheets, and inbound email attachments within the limits shown in the application. Procurement teams can choose an intake route that fits how documents already arrive.

Direct upload can be useful for testing a schema, handling an occasional document, or processing a controlled batch. Inbound email attachments can support a mailbox-oriented process when purchase orders are routinely received or forwarded by email. The team should still establish rules for which attachments belong in the workflow.

File intake is also the right point to apply operational controls outside the extraction step. Teams can decide who may submit documents, how original files are retained, and how duplicate submissions are handled. A clear naming or reference convention can make investigation easier when a document needs review.

Do not assume that every attachment is a purchase order. An email may also contain a quote, specification sheet, acknowledgment, or invoice. If mixed document types are expected, define how the team will identify and route them before relying on purchase order fields.

  • Upload PDFs, images, or spreadsheets supported within the application limits.
  • Use supported inbound email attachments where email-based intake is appropriate.
  • Retain a reference to the source document for review.
  • Define a process for non-PO attachments and duplicate submissions.

Extract supplier, date, line-item, and total fields

Once the schema and input route are defined, the extraction step maps document content into the requested fields. Supplier information may appear under labels such as vendor, supplier, or issued to. Date fields require particular care because one purchase order can show an issue date, delivery date, contract date, and revision date.

The schema should name each date according to its purpose. Putting every date into a generic document_date field creates ambiguity later. If a requested delivery date is not printed, the output should remain null rather than copying the issue date or calculating a date that the document does not state.

Line-item extraction should preserve row relationships. The description, quantity, unit price, and line total from one row must remain together in one object. A shifted value can produce valid-looking JSON while representing the wrong item, which is why line items deserve focused review on dense or irregular tables.

Totals also require semantic labels. Subtotal, shipping, discount, tax, and grand total should not be treated as interchangeable amounts. When a component does not appear, return null or follow the team’s documented representation instead of assuming it is zero.

  • Map supplier data by meaning, not page position.
  • Keep each date type in its own field.
  • Preserve all values from a line-item row as one object.
  • Distinguish subtotal, tax, shipping, discounts, and grand total.
  • Do not manufacture missing values.

Review fields that need attention

Document layouts vary, and some source files contain faint text, compressed images, handwritten notes, overlapping stamps, or tables split across pages. ParseBuddy lets users review fields that need attention. This review step should focus on values that could materially affect purchasing, receiving, or financial records.

A reviewer should compare the extracted value with the original document rather than relying only on whether the JSON is syntactically valid. A correctly formatted number can still be wrong. For example, 89.50 and 895.00 are both valid numeric values, but only one may match the unit price printed in the purchase order.

Teams should define what a reviewer may change and how corrections are recorded in their broader process. A reviewer can correct an extraction to match the source document, but should not rewrite the source to make an inconsistent purchase order balance. If the printed subtotal does not equal the sum of printed line totals, capture the printed values and route the discrepancy for procurement review.

  • Check purchase order numbers for missing or transposed characters.
  • Confirm supplier identity against the document header.
  • Inspect ambiguous dates and date formats.
  • Review line items with wrapped descriptions or multi-page tables.
  • Compare decimal placement in quantities and prices.
  • Escalate source-document inconsistencies instead of silently correcting them.

Validate the structured result

Extraction review confirms that fields match the source. Validation checks whether the resulting data follows expected business and mathematical rules. These are related but separate activities. A document can be extracted perfectly and still contain an unexpected currency, a duplicate purchase order number, or totals that do not reconcile.

Begin with required-field checks. A procurement workflow might require a purchase order number, supplier name, issue date, currency, at least one line item, and grand total. Optional fields should not block the workflow merely because a supplier does not include them.

Next, test arithmetic where the document provides enough information. For each row, quantity multiplied by unit price can be compared with the printed line total, while respecting rounding conventions. Line totals can be compared with the subtotal. The subtotal can then be reconciled with printed discounts, shipping, tax, and the grand total.

Validation should flag discrepancies rather than overwrite extracted values. This preserves the distinction between what the document states and what a calculation suggests. The team can then decide whether to contact the supplier, correct the purchase order at its source, or approve a documented exception.

  • Check required fields for null or empty values.
  • Confirm dates follow the expected format.
  • Verify that monetary fields have a currency.
  • Compare quantity × unit price with each line total.
  • Reconcile line totals with the subtotal.
  • Reconcile subtotal adjustments with the grand total.
  • Check purchase order numbers for duplicates in the receiving system.

Return structured JSON or use an outbound webhook

After review and validation, the completed purchase order data can be returned as structured JSON. ParseBuddy can also send completed results through outbound webhooks. JSON provides a clear contract for downstream processing because each field has a stable name and line items remain grouped as an array.

Before sending results onward, define how the receiving process handles null values, corrected fields, duplicate deliveries, and schema changes. A webhook recipient should not assume that every optional field will be present in every purchase order. It should also use a stable document or purchase order reference when guarding against duplicate processing.

The destination and action depend on the organization’s own systems and controls. Structured data might be queued for an internal application, checked against a requisition, prepared for an import, or added to an operations review list. Sending data onward should not automatically imply that the purchase order is approved.

Maintain a clear boundary between extraction status and procurement status. Completed extraction means the requested document fields have been processed. It does not mean the supplier is authorized, the budget is available, the prices match a contract, or the purchase has received required approval.

  • Use JSON field names that match the agreed schema.
  • Keep line items as structured objects.
  • Plan for null optional fields.
  • Protect downstream processes from duplicate submissions.
  • Version the schema when making breaking changes.
  • Do not equate completed extraction with purchase approval.

Operational practices for a dependable workflow

A dependable process is easier to maintain when ownership is explicit. Procurement can define required business fields, operations can manage intake and exceptions, and technical owners can define how completed JSON is accepted by downstream systems. The exact division of responsibility will vary, but unresolved fields should always have a clear destination.

Test the schema with synthetic purchase orders that represent common layout variations. Include single-page and multi-page tables, discounts, shipping charges, different currencies, missing optional fields, and revised purchase orders. Synthetic documents allow the workflow to be tested without exposing personal or commercially sensitive information.

When the schema changes, assess the effect on reviewers and receiving processes. Adding an optional field is usually easier to accommodate than renaming a field or changing its data type. Keep field definitions documented so users understand whether total means subtotal, amount due, or grand total.

Finally, preserve source fidelity. The extraction output should represent the purchase order as written. Normalized or enriched values can be created later, but they should remain distinguishable from extracted values. That distinction supports clearer review and more reliable exception handling.

  • Assign owners for intake, review, validation, and downstream handling.
  • Test with obviously fictional documents and varied layouts.
  • Document field definitions and allowed values.
  • Plan schema changes before deploying them.
  • Keep extracted values separate from normalized or enriched data.
  • Define an exception route for documents that cannot be completed confidently.

Example workflow

From document to usable data

1

1. Define the purchase order schema

List the supplier, identifier, date, currency, line-item, and total fields needed by the next process. Set data types and identify which fields are required.

2

2. Prepare the intake route

Upload supported files or use supported inbound email attachments within the limits shown in the application. Retain a reference to the source document.

3

3. Extract document fields

Process the purchase order against the defined schema, keeping line-item rows grouped as repeatable objects.

4

4. Review fields needing attention

Compare flagged or ambiguous values with the original document. Correct extraction errors to match the source without inventing missing data.

5

5. Run validation checks

Check required fields, date formats, currency, line calculations, subtotal reconciliation, grand total reconciliation, and duplicate purchase order references.

6

6. Resolve exceptions

Route inconsistent source documents, missing required values, or failed business checks to the appropriate procurement or operations owner.

7

7. Return the completed result

Use the structured JSON result or send completed data through an outbound webhook, while keeping extraction completion separate from purchase approval.

Synthetic product demonstration

Synthetic purchase order PDF → structured JSON

Fields to capture

  • • Purchase order number: PO-FICTION-1048
  • • Supplier: Northstar Office Supply — Fictional
  • • Buyer: Harbor Works Operations — Fictional
  • • Issue date: 2026-04-08
  • • Requested delivery date: 2026-04-22
  • • Currency: USD
  • • Line 1: CHR-200, Ergonomic Task Chair, quantity 3, unit price 245.00, line total 735.00
  • • Line 2: ARM-110, Adjustable Monitor Arm, quantity 8, unit price 89.50, line total 716.00
  • • Line 3: CBL-020, Desk Cable Kit, quantity 20, unit price 18.25, line total 365.00
  • • Subtotal: 1816.00
  • • Shipping: 84.00
  • • Tax: 152.00
  • • Grand total: 2052.00
{
  "document_type": "purchase_order",
  "purchase_order_number": "PO-FICTION-1048",
  "supplier_name": "Northstar Office Supply — Fictional",
  "buyer_name": "Harbor Works Operations — Fictional",
  "issue_date": "2026-04-08",
  "requested_delivery_date": "2026-04-22",
  "currency": "USD",
  "line_items": [
    {
      "item_code": "CHR-200",
      "description": "Ergonomic Task Chair",
      "quantity": 3,
      "unit": "each",
      "unit_price": 245.00,
      "line_total": 735.00
    },
    {
      "item_code": "ARM-110",
      "description": "Adjustable Monitor Arm",
      "quantity": 8,
      "unit": "each",
      "unit_price": 89.50,
      "line_total": 716.00
    },
    {
      "item_code": "CBL-020",
      "description": "Desk Cable Kit",
      "quantity": 20,
      "unit": "each",
      "unit_price": 18.25,
      "line_total": 365.00
    }
  ],
  "subtotal": 1816.00,
  "discount": null,
  "shipping": 84.00,
  "tax": 152.00,
  "grand_total": 2052.00
}

Frequently asked questions

What fields should a purchase order extraction schema include?

A practical starting point includes the purchase order number, supplier name, buyer name, issue date, requested delivery date, currency, line items, subtotal, discount, shipping, tax, and grand total. Add contract references, cost centers, delivery locations, or payment terms only when the downstream workflow needs them.

How should line items be represented?

Represent line items as an array of objects. Each object can contain an item code, description, quantity, unit, unit price, and line total. This structure supports purchase orders with different numbers of rows and keeps values from the same row together.

What happens when a field is missing from the purchase order?

If the field is optional, return null or use the absence convention defined in the schema. Do not infer an unstated delivery date, currency, tax amount, or other value. If the field is required, send the document to the team’s exception process.

Should an incorrect printed total be fixed during extraction?

No. Extraction should capture what the source document states. A validation rule can flag that the printed total does not reconcile with the line items, but the discrepancy should be resolved through the procurement process rather than silently changing the extracted value.

Can completed purchase order data be sent to another system?

ParseBuddy can return structured JSON and send completed results through outbound webhooks. The receiving process should be designed to handle optional fields, duplicate submissions, exceptions, and future schema changes.

Does completed extraction mean a purchase order is approved?

No. Extraction completion means the requested fields have been processed. Supplier authorization, contract matching, budget checks, and purchase approval remain separate business controls.

Which document inputs can be used in this workflow?

Supported workflows include PDFs, images, spreadsheets, and inbound email attachments within the limits shown in the application. Teams should choose an input route that matches their document intake process and review the applicable limits before implementation.

Build a structured purchase order workflow

Define the purchase order fields your team needs, test the schema with fictional documents, and use ParseBuddy to turn uploaded documents or supported email attachments into structured data. Review fields that need attention, then return completed JSON or send results through an outbound webhook.

Start free — no card required