A practical way to turn a certificate template into thousands of signed, verifiable documents.
The first certificate is easy. Someone finishes a course, you put their name on a nice-looking page, export a PDF and email it. The trouble starts when you have 500 graduates, or 5,000. Names get copied into the wrong places. Old templates resurface. A recipient asks whether the document is genuine, and all you can offer is a logo and a signature image.
A better approach doesn’t require an elaborate document system. It starts with a printable PDF template, uses structured data to fill it, and finishes with a real digital signature. Done carefully, the same process works for one certificate or an entire graduating class.
Let’s use a certificate of completion for a professional training course as our example. The principles apply equally well to examination results, employee qualifications, professional training, membership confirmations and other documents that an organization needs to issue and stand behind.
What should a digital certificate actually prove?
A certificate has two jobs. It must tell a human what happened, and it must give a third party a reliable way to check who issued the document and whether its contents have changed.
The visible part is familiar: the recipient’s name, qualification, issuer, completion date and a unique certificate number. It should look good on a screen and still make sense when printed on A4 paper.
The less visible part matters just as much. We need a document format that can be reproduced reliably years from now, a cryptographic signature connected to the issuing organization, and preferably a trusted timestamp. For certificates that must remain verifiable over a long period, we also need a plan for keeping certificate-chain and revocation evidence.
One distinction is worth making at the outset: we’re talking about PDF certificates of achievement or completion, not the X.509 digital certificates used by public-key infrastructure. An X.509 certificate may be used to sign the PDF, but the two are different things.
Design the certificate once
Start with the page, not the code. A certificate is a document people may print, frame, attach to a job application or submit to an auditor. A good template is more valuable than a complicated rendering engine.
For this example, imagine a one-page document with a modest border, the issuer’s logo, a clear title and enough space for longer names. Its variable content might look like this:
CERTIFICATE OF COMPLETION
This certifies that Olivia Bennett has successfully completed Advanced Database Development.
Completion date: 18 September 2026
Certificate ID: NTI-2026-01842
Issued by: Northbridge Training Institute
You can create the design in Adobe Acrobat, but LibreOffice Writer is a useful free alternative. In Writer, build the layout as an ordinary document and add text controls using the Form Controls toolbar. Give each control a deliberate name, such as recipient_name, qualification, completion_date, certificate_id and issuer_name.
Then choose File → Export As → Export as PDF and enable Create PDF form. The result can be an AcroForm PDF: a document whose appearance is already designed, but whose named fields can be populated by software. Acrobat’s Prepare a Form tools offer another route to the same result.
LibreOffice also offers a PDF/A-3b export option. Whether you can use both options in the exact way you want depends on the document and export behavior, so inspect the actual exported form rather than assuming every setting combination is interchangeable. For a straightforward production workflow, it is perfectly reasonable to create an ordinary fillable PDF as the working template, then ensure the finished certificate meets the chosen PDF/A profile before signing.
And a small terminology trap: FDF in the LibreOffice export dialog is a form submission data format. It is not the type of PDF form, and you don’t need FDF if your application is going to populate the fields from JSON.
Why PDF/A instead of an ordinary PDF?
An ordinary PDF is excellent for distributing something that looks the same on different devices. PDF/A adds a stricter set of rules intended for long-term preservation. Among other things, it addresses embedded fonts, color information and document features that could make future rendering unreliable.
PDF/A and digital signatures solve different problems: one is about preserving the document, the other about establishing who signed it and whether the signed content has changed. You often want both.
For this example, PDF/A-3b is a useful target. The b level focuses on faithful visual reproduction; PDF/A-3 also allows appropriately associated files, such as an XML record, to be embedded if the workflow needs them. If you don’t need attachments, PDF/A-2b may be an equally sensible—and simpler—choice. PDF/A-3b is not automatically “better” than PDF/A-2b for every certificate.
This is especially important with names. You don’t want a certificate for “Renée Müller” to lose characters because a font wasn’t embedded or its glyphs weren’t available in the final PDF.
Don’t treat a PDF/A label in the document metadata as proof of compliance. After generating the final document, run a validator such as veraPDF. Check the actual output—after filling and flattening—and, again, after any signing or preservation updates. Every step that changes PDF objects can affect compliance.
Fill the form from data
Now the interesting part: the design doesn’t change from one recipient to the next. Only the values do.
A record for our example could be represented in JSON like this:
{
"fields": {
"recipient_name": "Olivia Bennett",
"qualification": "Advanced Database Development",
"completion_date": "18 September 2026",
"certificate_id": "NTI-2026-01842",
"issuer_name": "Northbridge Training Institute"
}
}
The keys must match the actual field names in the exported PDF. Some document tools generate different names, so inspect the form before integrating it. In an Oracle application, a function that extracts the existing field names and values is handy for this.
Here is the core PDF-filling operation using PL/ACROFORM from PLslash. l_template_pdf is an existing PDF BLOB loaded from a table or another application source; l_data contains the JSON shown above.
l_certificate_pdf := pl_acroform.fill(
p_pdf => l_template_pdf,
p_data => l_data,
p_format => 'JSON',
pl_flatten => true
);
Notice the final parameter. It requests a fill-and-flatten operation in one pass, rather than saving an intermediate interactive PDF and opening it again. For workflows in which the recipient is meant to edit the form, leave pl_flatten as false instead.
This is a small amount of code because the layout lives in the PDF template. The application doesn’t need to recalculate text positions, borders or fonts for every recipient. It provides data; the form supplies the presentation.
Flatten before you sign
Once the fields are filled, there’s usually no reason for a certificate to remain an interactive form. That is where flattening comes in.
Flattening takes the visible appearance of each completed form field and puts it into normal PDF page content. The interactive widgets can then be removed. The person opening the result sees the completed certificate rather than a document full of editable input boxes.
That is different from security. A flattened PDF can still be edited with sufficiently capable software. Flattening makes the document a better final artifact, but it does not provide cryptographic integrity and it is not secure redaction. An incremental PDF update may retain older bytes even when a field is no longer active.
The order of operations matters:
Template → Fill → Flatten → PDF/A conformance check or conversion → Digital signature and timestamp → Final validation
If the post-flatten PDF needs conversion or normalization to meet PDF/A requirements, do that before signing. Rewriting a signed PDF generally breaks the signature. Likewise, any optional attached data or metadata that belongs in the certified document should be added before signing.
A digital signature is not a picture of a signature
A scanned signature or an image of a stamp may look official, but anyone can copy it. A cryptographic PDF signature works differently. The issuing organization signs a digest of the document using a private key associated with a signing certificate. A verifier can detect changes to the signed content and examine the signer certificate and its trust chain.
In PDF workflows, this is commonly done with PAdES signatures. A PAdES B-T signature adds a trusted timestamp from a timestamp authority (TSA). That timestamp gives evidence that the signature already existed at a particular time; it does not independently prove the course completion date printed on the certificate.
If a certificate is expected to remain verifiable for many years, look beyond basic signing. PAdES B-LT incorporates validation material, and B-LTA adds archival timestamp protection for that material (European Commission DSS documentation). The appropriate level depends on retention requirements, trust policy and the available signing infrastructure.
There is another distinction worth stating plainly: a valid digital signature proves that a particular signing credential was used and helps detect changes to the signed document. It cannot, by itself, prove that the recipient really passed the examination. That factual claim remains the responsibility of the issuer.
From one certificate to five thousand
The same workflow scales surprisingly well because the document design and the business data remain separate.
Imagine a training system with an approved list of successful candidates. For each record, the application assigns a certificate ID, populates the PDF fields, flattens the result, checks PDF/A compliance, applies the issuer’s digital signature and timestamp, validates the result, and stores the finished document for download or delivery.
A simple production sequence looks like this:
- Confirm the qualification result and approve issuance.
- Assign a unique, non-reusable certificate identifier.
- Fill and flatten the approved PDF template using the recipient’s data.
- Ensure the finished document conforms to the required PDF/A profile.
- Sign with the issuer’s authorized credential and obtain a trusted timestamp.
- Validate the signature and PDF/A output, then archive and deliver the file.
The signing key should be controlled by the issuer, ideally through an appropriate managed key store or HSM where the security requirements justify it. A batch job should not contain a private key or its password in source code.
For an additional verification layer, include a QR code or short verification URL linked to the certificate ID. That lets an employer or auditor check the issuer’s current records, including whether the certificate has been withdrawn. The QR code doesn’t replace the digital signature; it solves a different problem. A cryptographically valid historical certificate and a currently valid qualification are not always the same thing.
How do you know the finished document is right?
Before calling this production-ready, test a few cases that tend to break certificate generators: unusually long names, accented characters, missing optional values, duplicate certificate IDs, and templates updated after a course has already been completed.
Then test the delivered PDF, not just the template:
- Does the document look correct on screen and on paper?
- Are the final form widgets gone, and is the recipient’s data visible?
- Does a PDF/A validator accept the final signed document?
- Does a trusted PDF viewer report a valid signature, timestamp and certificate chain?
- Can the issuer’s registry resolve the certificate ID?
Keep the original issuance record and the final signed PDF. This gives the issuer a clear audit trail without relying on the PDF alone as the system of record.
Putting it together in Oracle Database
If your application already runs on Oracle, there’s no need to export records to a separate application just to fill the PDF form. PL/ACROFORM handles AcroForm data extraction, JSON-based filling and flattening directly from PL/SQL, using Oracle BLOBs. The fill(..., pl_flatten => TRUE) option produces a static result in a single PDF processing pass.
Once the certificate is finalized and any PDF/A requirements have been met, PL/SIGN can apply PDF digital signatures and trusted timestamps as part of the Oracle workflow. PDF/A conformance should still be checked independently on the delivered document.
That is the useful part of this approach: designers can work in Acrobat or LibreOffice, developers can work with structured records and PL/SQL, and recipients get an ordinary PDF they can open, print and verify.
The end product doesn’t need to look technological. It should look like a certificate—and have the evidence behind it to deserve the name.
