From magazine topic to project implementation
Relevant service and technical pages for this post
The impetus rarely comes from IT. It arrives by email from sales or accounting, at the last minute: “Two invoices were returned. From next week only ZUGFeRD or XRechnung, otherwise no acceptance.” The ticket description often contains a sentence that sounds like a small matter: “We already print PDFs — can’t we just convert them?”
The complete feature overview, editions and downloads can be found on the netPDF product page.
At that exact moment it is decided whether the issue will explode as a “quick conversion” at month-end closing or become a manageable process. The less helpful response is frantic: test some online converter, run a few PDFs through, done. The better response is sober: first stabilize the output path, then place a verification layer (Gatekeeper) in front of it — and only then automate where it truly pays off. This pattern is where netPDF microAI fits: detect PDF invoices locally, output them in a standardized way via a virtual e-invoice printer, and finally produce ZUGFeRD or XRechnung — but only if the validation rules pass.
The critical moment: “Converting” sounds technical, but it is a process issue
When an organization has so far “printed” invoices as PDFs, this is often a proven approach: the layout has been approved, the archive accepts PDFs, recipients could work with them. With e-invoices the emphasis shifts. Suddenly it is not only the visual rendering that matters, but the structure: mandatory fields, identifiers, tax logic, line-item data.
The misconception is: “We have all the information in the PDF, so we’ll just extract it.” In practice this means you have to recover machine-readable data from a document created for humans. That can work — but only with clear boundaries, reliable validation and a clean operational logic for special cases.
ZUGFeRD and XRechnung: specification is not a solution
For classification it is useful to draw a clear distinction: ZUGFeRD and XRechnung are formats or specifications. They describe how invoice data must be structured. A tool like netPDF implements these requirements in daily operation: generate, embed, validate, convert — and do so in an environment you can operate.
ZUGFeRD is hybrid: PDF plus embedded XML
ZUGFeRD is defined as a hybrid format: a human‑readable PDF additionally carries structured invoice data as XML. This allows people to read the PDF and systems to process the XML automatically.[Quelle] For IT and operations this implies something very concrete: you must not only “produce a file”, but ensure the consistency between the visual representation (PDF) and the structure (XML). If these diverge, queries, rejections or incorrect postings result.
A constraint that quickly becomes operationally relevant: exactly one invoice‑data XML per PDF/A‑3
The ZUGFeRD FAQ contains a rule that often shows up too late in projects: only one invoice‑data XML may be referenced per PDF/A‑3 document.[Quelle] That sounds like a detail, but it affects real requirements: the concepts “we’ll attach a second XML for safety” or “we’ll pack multiple structured attachments into one invoice” are not provided for. Attachments then belong in separate documents or in clearly defined non‑XML attachments — and the process must represent that.
XRechnung: pure XML, often the stricter validation benchmark
XRechnung is pure XML. In many receiving scenarios this XML is what is validated and either accepted or rejected. Even if a PDF is sent in addition: the decision is made based on structure, required fields and consistency. For testing this means: not only “a file is produced”, but “recipient/validator logic is fulfilled”.
What netPDF microAI addresses in this scenario — without making itself bigger than necessary
From the perspective of IT management, project owners and admins, the main interest in netPDF is that it maps a local toolchain that is often missing in mature landscapes:
- PDF invoice recognition (local): Support for detecting information in PDFs without uploading documents to cloud providers.
- Generate and validate e‑invoices: Create, convert and validate ZUGFeRD/XRechnung prior to dispatch.
- E‑invoice printer as an integration lever: Virtual printer “netPDF E‑Rechnung” as a standardized output path from applications that do not themselves provide structured export.
- PDF processing for process hygiene: Clean pages/structure and redact content when required for storage, transfer or recognition.
The benefit does not arise automatically from “AI”, but from the combination of standardization (an output channel), validation logic (gatekeeper) and traceable handling (storage, versioning, evidence). Without this chain it remains at individual cases that get stuck in support.
The less helpful reaction: online converters and hope
Why is “just convert” so tempting in enterprises? Because it yields short‑term signals of success: a PDF is “somehow” turned into ZUGFeRD, a test file looks fine. The problem appears later, usually in three variants:
- A recipient rejects it because mandatory fields are missing or data is inconsistent.
- After a layout update in the source system, recognition silently fails at some point.
- No one can later explain why an invoice was generated differently than the previous one (version, user action, processing step, validation environment).
This is not a moral argument against converters, but an operational observation: Without process boundaries, ‚conversion‘ becomes a source of tickets.
The better response: Gatekeeper design with clear stop criteria
A Gatekeeper here is not a new system but a defined process step: every generated e-invoice must be reviewed. Only if it meets the established rules may it be sent or posted. Everything else goes into exception handling with clear responsibility.
That sounds like additional effort. In reality it is a redistribution: you invest in predefined rules and save uncontrolled rework, bounce-backs and ‚error‑pingpong‘ between the business unit and IT.
Constructed everyday scenario: What ‚local recognition‘ saves in practice — and what it doesn’t
Why ‚local‘ for IT means not only data protection but operational responsibility
Local processing reduces dependencies on external AI services and prevents invoice data from crossing a cloud boundary. That can simplify governance — but it solves nothing if operation and rollout are unclear. In a local architecture, IT becomes more the operator of the entire document path.
The typical operational questions are concrete:
- Versioning: Which version of the tool/rules produced an invoice? Can you demonstrate that retrospectively?
- Intermediate data: Where do temporary files, OCR intermediate states or working copies end up? How are they cleaned up?
- Permissions: Who may perform recognition, who may redact, who may perform the final generation? Are roles separated where organizationally necessary?
- Traceability: Is there a validation report or status that is immediately visible in case of a ticket?
Those who clarify this early get a controlled output path. Those who leave it open invite shadow processes: local storage, manual PDF editors, non-reproducible corrections.
Editing and redacting PDFs: seemingly minor, but often the difference between ‚works‘ and ‚fails‘
In many companies the incoming and outgoing situation with PDFs is not ideal. Invoices contain attachments, pages with general terms and conditions, scans are skewed, pages are duplicated, or a document may be shareable internally in full but externally only with redactions. As soon as structured data must be derived from PDFs, any impurity has an effect.
Therefore PDF functions such as splitting/merging pages, correcting page order or redacting content are not a “comfort” feature but process hygiene. For IT the individual function matters less than the guardrail: Are original and working copy handled cleanly? Is it clear what is being archived? And is it traceable who made which edit when?
E-invoice validation: “Generated” is not a quality attribute
An e-invoice can be technically generated and still fail: mandatory fields are missing, totals are not consistent, tax logic does not match the recipient, or PDF and XML contain divergent content. Especially with document-driven recognition (reading PDF, deriving XML) this is not an edge case but a typical error class.
The hybrid core idea of ZUGFeRD makes the obligation to validate particularly clear: the PDF is readable by humans, the XML is intended for systems — both must describe the same invoice.[Quelle] Practical consequence: validation is not just a “checkbox” but a gate for production.
The e-invoice printer as an integration pattern: fast, but only with guardrails
The virtual printer is often the most pragmatic lever in established landscapes: many applications cannot “export an e-invoice”, but they can print. The print path thus becomes the integration point.
That this pattern is used in business applications is also shown by the documentation of an ERP vendor, which describes ZUGFeRD as an output option in the print process (via print/layout properties), instead of treating the topic exclusively as a separate interface.[Quelle] For IT this confirms: “print to file” is a realistic entry point — but only an entry point, not a quality guarantee.
The printer introduces new failure modes you should plan for: “printing again” creates duplicates, changes to the default printer lead to incorrect outputs, and in RDS/VDI environments printer assignment quickly determines success or chaos. This is not an argument against the pattern, but a pointer to the required operational framework.
Decision matrix: start document-driven, follow up data-driven
In projects an honest prioritization pays off. There are two basic approaches — and both can coexist within the same company.
| Approach | How is the invoice XML generated? | Operational advantage | Typical risk |
|---|---|---|---|
| Data-driven (source system provides structure) | Invoice data come directly from ERP/FiBu/individual company software; XML is produced from that, PDF is the presentation. | High reproducibility, clean tests, fewer interpretation errors. | Changes in the source system take time; they depend on release cycles and interfaces. |
| Document-driven (recognition from PDF) | Information is derived from PDF text/OCR/parsing and then generated as ZUGFeRD/XRechnung. | Faster start, usable with legacy systems, consistent output path via printer. | Layout drift, scans and special cases increase verification effort; validation is mandatory. |
As a scenario it is often sensible to start document-driven to become operational — and for high-volume, stable sources to move to data-driven in the medium term. Over time that reduces precisely the error classes that arise from interpretation.
Rollout in seven steps: so that month-end closing is not the test environment
A stable e-invoicing process is less an „installation package“ and more a controlled procedure. This sequence of steps is deliberately phrased operationally:
- Capture recipient requirements: Which recipients require ZUGFeRD, which XRechnung? Are there mandatory fields that typically are missing for you (e.g. purchase order references, service period, Leitweg-IDs)?
- Start with a few invoice types: Begin with clear types (standard invoice, credit note). Special cases later, but planned.
- Define gatekeeper rules in writing: Which errors must mandatorily stop processing? Who may approve or correct? Where is it documented?
- Define a pilot ring: Small group, fixed test cases, clear feedback channel. Each error is assigned a category (layout, mandatory field, duplicate, permission issue).
- Clarify storage and audit logic: Original, working copy (if edited), result file and audit report must be unambiguously linked (document number, timestamp).
- Test RDS/VDI and standard printer issues in advance: Installation via software distribution, printer mapping, user profiles, permissions on output/storage paths.
- Establish regression tests: A set of representative invoices is run after updates or layout changes — before broad rollout.
The point is not to perfect everything, but to close the typical failure points early: duplicates, missing mandatory fields, unclear responsibilities and missing evidence.
Risks and clear limits: where automation deliberately stops
Layout drift remains a structural problem
If the PDF layout in a source system changes, recognition can fail — even if „content-wise nothing else“ has changed. This is not a surprise but a property of unstructured documents. The countermeasure is a regression test set and a clear rule: a layout change is a test trigger, not a „it will be fine“.
Scans and image PDFs increase verification requirements
Scanned PDFs often lack a clean text layer. OCR can help but remains more prone to transposed digits or incorrect special characters. Operational consequences: higher sampling rate, more focus on document cleanup (e.g. rotate pages, improve contrast/quality) and more conservative abort rules.
Duplicates caused by „print again“ must be planned for
A virtual printer lowers the threshold for repeats. Without versioning and duplicate-detection logic, files produced multiple times will later not be cleanly distinguishable. Therefore decide early how repeats are detected and handled (e.g. as a new version instead of as the “same document”).
When this pattern is a particularly good fit — and when you should reprioritize
The approach using netPDF microAI and e‑invoice printers is particularly suitable when you:
- have multiple applications that must deliver e‑invoices on short notice but currently only output PDFs,
- want to keep data flows deliberately local (governance/data protection/dependencies),
- can establish a central, operable document path (software distribution, permissions, logs, storage).
The pattern is less suitable as a long‑term solution when a source system is stable, modernizable and high‑volume: in that case it pays off in the medium term to build a data‑driven export instead of permanently “guessing” from PDFs.
Boundary: a bridge yes — but only with operational discipline
A local recognition approach and an e‑invoice printer are a realistic bridge when time pressure and evolved system landscapes coincide. The boundary is equally clear: without validation, audit reports and an exception process, the bridge becomes a generator of rejections and rework. netPDF microAI can provide tools in this scenario — responsibility, however, rests with your operations design: gatekeeper rules, clean storage, pilot rings and regression tests.
If you want to evaluate this for your system landscape in a structured way (sources, invoice types, gatekeeper rules, rollout in RDS/VDI, traceability), this can be clarified in a technical preliminary discussion: get in touch.
Sources and further information
The technical core statements were editorially contextualized using the following external sources.
- ZUGFeRD/Factur-X (www.ferd-net.de)
ZUGFeRD is defined as a hybrid format: a PDF with additionally embedded structured invoice data (XML) for automated processing. - About ZUGFeRD (www.ferd-net.de)
Only one invoice-data XML can be referenced per PDF/A‑3 document; multiple invoice XMLs in a single document are not envisaged. - Auvorgangsdruckzugferd – microtech Help (hilfe.microtech.de)
Issuing ZUGFeRD via the print process is an established pattern in business applications (e‑invoice format as a print/output option).
Converting ZUGFeRD is also important for this topic. The article places these aspects in context in an understandable way and shows what matters in everyday practice.
Discuss a project or modernization initiative with Net-Base.
Next step
When the topic becomes an actual project, architecture, existing systems and operations should be considered together from the outset.
We support not only with individual issues, but also when source snippets, legacy topics, or portal ideas are to be turned into a robust enterprise project.
- Current state, target state and technical risks are assessed jointly.
- REST, data access, portals and rollout are not deferred to a later stage as secondary consequences.
- You can see early on which path is economically and operationally viable.