Polotno SDK covers both halves of certificate generation: an embedded editor where your users design the certificate, and a render pipeline that fills it from data (names, courses, dates, QR verification codes) at any volume. Most certificate tools give you one half. Platforms need both: course creators want to design their own certificate; the system needs to issue five hundred of them on completion day. This is production infrastructure for issuance, not optional UI.
The two-sided certificate problem
Certificate features start simple (one PDF template, a name field) and grow teeth. Instructors want their own branding. HR wants the legal line changed without a support ticket. The awards run needs 2,000 personalized files in an hour. A homegrown coordinate-based PDF generator handles exactly none of that gracefully, and the person who positioned the text boxes has usually left.
The structural fix is one design format shared by an editor and a renderer. In Polotno that's the JSON schema: your users design in the embedded editor, your backend feeds the same JSON plus a data row to polotno-node or the Cloud Render API, and every certificate is both pixel-faithful to the design and personalized from your data.
Key features
Self-serve certificate design
Embed the editor so course creators, event organizers, and HR admins design certificates themselves, your fonts and templates as starting points, no design tickets.
Template governance
Lock the layout, seal, and legal text; expose name, course, and date as editable or data-driven slots. Every issued certificate stays on-brand and legally correct.
Data-driven batch issuance
Drive templates with dynamic variables from your completion events or a CSV. One template, thousands of personalized PDFs or PNGs.
QR and verification codes
Place per-certificate QR codes linking to your verification endpoint, generated at render time from the same data row. See the QR automation guide.
Print and digital output
A4/US Letter PDFs for printing, PNGs for email embedding and social sharing, same design, both outputs.
Issue-time rendering
Render on completion events via API. No queue of manual exports, no designer in the loop on issuance day.
Example use cases
- LMS platforms where instructors design course-completion certificates.
- HR and people-ops tools issuing recognition and training certificates.
- Event platforms generating attendance certificates after each event.
- Professional associations issuing membership and CPD certificates with verification QR codes.
- Bootcamps and course marketplaces batch-issuing on cohort completion.
Developer benefits
- One JSON schema drives the editor and the render pipeline, no drift between what was designed and what gets issued.
- Batch generation via polotno-node on your infrastructure or the Cloud Render API.
- Template variables for names, dates, scores, and QR payloads.
- Editor governance keeps user-designed templates issuable.
- A working starting point: the bulk certificate generator tutorial is a 40-line pipeline you can lift.
FAQs
Can our users design their own certificates?
Yes. That's the reason to embed the editor rather than call a render-only API. Governance controls what they can change.
How fast can we issue a large batch?
Sequential rendering with a reused instance handles hundreds comfortably; for burst issuance at larger scale, the Cloud Render API takes the same JSON with no infrastructure on your side.
Can certificates include verification QR codes?
Yes. Generate the payload per recipient and place it via template variables at render time.
PDF or image output?
Both, from the same design: PDF for print, PNG/JPEG for email and sharing.
Where does the certificate data live?
In your systems. Design JSON in your database, recipient data in your pipeline; rendering runs on your infrastructure unless you opt into the cloud API.
