/ Platform overview

Epistola renders PDFs. Your products handle everything else.

Templates, data bindings, and a rendering engine that respects Common Ground standards — all open source.

/ Everything you need to render PDFs

Epistola does templates and rendering — nothing else.

Keep workflows in the products that orchestrate your cases while Epistola focuses on perfect output.

Templates

Template lifecycle

Variants, immutable versions, and draft/publish/archived states per tenant with audit trails and schema migrations.

Learn more

Authoring

Visual editor

Drag-and-drop blocks with conditional logic, loops, live PDF preview, and inline expression chips.

Learn more

Logic

Expression engine

Use flexible expressions to calculate totals, format values, and apply conditional logic. Define input variables per template.

Learn more

Rendering

Direct PDF renderer

Render PDF/A and PDF/X outputs directly — no HTML conversion step. Handles 10,000+ documents per minute on simple hardware.

Learn more

Operations

Multi-tenant governance

Role-based access, environment promotions (staging/production), and per-tenant default themes keep teams isolated.

Learn more

Delivery

API + jobs

OpenAPI 3.1 REST endpoints for single or batch renders with adaptive job sizing, webhooks, and storage adapters.

Learn more

/ Template system

How Epistola templates stay organized

Variants, immutable versions, JSON Schemas, and environment activations all live inside the suite so integrations stay simple.

Schema

JSON Schema Draft 2020-12

caseNumber
string required
decisionDate
string(date-time) ISO 8601
citizen.name
string minLength 2
citizen.address
object street, postalCode

Examples

  • citizen-approved.json default happy path
  • citizen-rejected.json conditional clauses
  • business-appeal.json variant attributes

Template

Public Decision Letter

Template slugs stay tenant-scoped. Variants inherit schema + theme but keep their own immutable version history.

nl-standard

nlcitizen
v7 draft immutable
v6 published immutable

en-business

enbusiness
v4 published immutable

Generation requests can skip `variantId`. Provide attributes such as `language=nl` or `brand=business` and the resolver scores every variant, picking the closest match and falling back to the default if nothing satisfies required criteria.

Variant resolver

Attribute intent → required filter → optional scoring → fallback safety net

  1. 1

    Describe intent

    Callers send attributes with required vs optional flags.

    • language=nl
    • brand=citizen
  2. 2

    Filter on required

    Any variant missing a required attribute drops out immediately.

    • nl-standard ✓
    • en-business ✗
  3. 3

    Score optional matches

    Optional matches + specificity award points.

    • nl-standard → score 12
    • default → score 0
  4. 4

    Select & fallback

    Highest score wins; default variant stays as the safety net.

    • Chosen: nl-standard v7
    • Fallback: default variant

Audit trail

Publishing locks the theme snapshot + schema hash so every request can be reproduced years later.

Environments

Activate per stage

Staging immutable pointers
  • nl-standard v7 draft
  • en-business v4
Production immutable pointers
  • nl-standard v6
  • en-business v3

Promote by switching the active version pointer; rollbacks are instant because older versions stay archived.

Themes

Cascade across tenants → templates → variants

  • Tenant default: Gemeente sans + amber palette
  • Template override: add watermark + section spacing
  • Variant tweak: en-business switches bilingual heading font

Validation

Schema + example replay before render

Render requests fail fast if the payload drifts from the JSON Schema. Named examples replay automatically in CI to protect variant versions before they hit production environments.

/ Feature deep dive

The Epistola Suite in practice

Straight from the reference implementation: how templates evolve, feedback gets routed, and assets stay governed.

Lifecycle

Templates, variants, versions, environments

  • Each tenant owns template slugs with unlimited variants tagged by geography, brand, or audience.
  • Variants carry immutable version numbers with a draft → published → archived lifecycle and audit history.
  • Environments (staging, production, custom) activate specific versions so you can test or roll back safely.
  • Variant resolver inspects request attributes (e.g., language=nl) and picks the closest match automatically, falling back to the default when nothing fits.

Contracts

Data schemas and executable examples

  • Every template ships with a JSON Schema Draft 2020-12 data contract validated pre-render.
  • Named example payloads live beside the schema for instant previewing and regression fixtures.
  • Schema migrations keep draft versions in sync when fields change between releases.

Feedback

Built-in reviews with screenshots

  • Floating feedback button opens a modal that captures URL, user context, and console logs.
  • Drag in or paste screenshots—assets upload automatically and render in the feedback timeline.
  • Optional GitHub sync mirrors issues bi-directionally so engineers can triage where they work.

Themes

Tenant and variant theming

  • Reusable theme packages define typography, color tokens, and page settings (A4, Letter, margins).
  • Theme cascade respects tenant defaults, template overrides, then variant-specific tweaks for special cases.
  • Block-level presets make it easy to enforce branded tables, headers, and emphasis patterns.

Assets

Tenant asset manager

  • Upload PNG, JPG, SVG, or WebP up to 5 MB via drag-and-drop with automatic thumbnailing.
  • Assets live per tenant with search, delete, and direct references inside the template editor.
  • Raw endpoints serve optimized binaries to the renderer so logos stay crisp in every PDF.

/ DocOps architecture

Editor → template service → renderer: a single document generation lane.

Epistola Suite is unapologetically about generation, not analytics or AI insights. Authors design templates, developers automate the render API, and platform teams run the Helm stack — all centered on getting compliant PDFs out the door.

Business authors

Drag/drop blocks, manage schema examples, and preview PDFs with inline expression evaluation.

  • Block library: text, tables, columns, clauses, headers, footers
  • Undo/redo + autosave stacks
  • Inline expression tester

Developers

Version templates in Git, run Testcontainers suites, and invoke the OpenAPI-render API from orchestrators.

  • API commands for template + theme automation
  • Adaptive batch jobs with job states and metrics
  • Webhooks + storage adapters (S3, Azure, DMS)

Platform ops

Deploy Helm charts with Keycloak/OIDC, monitor renders, and promote versions across environments.

  • Multi-tenant isolation + RBAC memberships
  • Environments per tenant (staging/production)
  • Prometheus/OTel metrics + health probes

/ Built for integrators

Leave orchestration where it already lives.

Epistola exposes a guarded render surface that fits into Common Ground and bespoke platforms without forcing workflow rewrites.

  • JSON Schema Draft 2020-12 validation before render
  • Immutable template versions per environment and tenant
  • OpenAPI 3.1 endpoints + adaptive batch job webhooks

50-200 ms

render window (iText)

/ Next step

Interested in what Epistola can do for your product?

Schedule a call and ask us any of your questions.

Hoe wilt u contact opnemen? *