Questions
The short answers. If your question is not here, Concepts defines the terms the site uses, and the help section says where to ask.
What is Datum?
Forms infrastructure you run in your own environment: your forms, your data, your keys. Design a form once and render it on any page. What comes out is the output you choose: a submission validated in a WASM sandbox on your own server, a PDF from a layout you designed or an existing PDF filled in, a printed page, a JSON record, a signature with PIV or WebAuthn. It is a set of packages you host, not a service you subscribe to.
Do we have to replace the forms we have?
No. Datum runs beside what you run today, one form at a time. The form goes on the pages you already have with one script tag, an existing fillable PDF can stay as the form's layout and be filled from the answers, and your server takes a PDF someone filled in any viewer, or JSON from any client, into the same records as the web form.
What happens to our fillable PDFs?
They keep working, and each step can be taken on its own. Add a PDF to its form as a layout, and Datum fills the original's fields from the answers. Keep accepting the PDF itself: when a registered form has it as a layout, your server reads a filled copy's fields into a record and validates it like any other. Or build the form from it: Create form fields makes a form field for every field in the PDF. PDFs says what is carried over and what is not.
Do I need a server?
No. The builder, the renderer, the validation sandbox, PDF generation and the signature tooling all run in the browser, so a team can design, test and publish a complete form without a server. A person filling it in can print it, download a PDF, or download the answers as a JSON file with the download button action. Signing a PDF as the person needs the small local agent described under signing. When submissions should be kept in one place, signed with a server's key, or verified centrally, a server takes over without changing the form. Any host that runs WASM can be that server: Spring Boot and FastAPI hosts are built, and Your own server covers the rest, with worked examples in Python, Java, .NET and Node.js.
Does it run without network access?
Yes. The bundles, fonts, the sandbox and the PDF program ship as files you serve yourself, and nothing is fetched from a third party at runtime, so an air-gapped deployment works the same as any other. Files you host lists them.
Which frameworks does it work with?
Any. The form and the builder are web components loaded with a script tag, with TypeScript typings for the elements. A React page uses them like any custom element.
How does validation stay consistent between the browser and the server?
One sandbox program runs on your server inside a WASM sandbox, and can run in the page while you develop and test. The same definition and the same answers produce the same verdict, byte for byte. See Validation and the sandbox.
Can we test a form?
Yes. A test is a short scenario in plain words, kept with the form: set some answers, press Continue or Submit, and expect a field shown or required, a page on the path, a submission refused with a given error, or an answer withheld. The builder runs the suite as you edit, and the same scenarios run from the command line on the browser's runtime and on the server's sandbox program, so a difference between the two sides is a finding of its own. See Testing a form.
Can an assistant fill a form?
Yes, in a browser that supports WebMCP, when the form is set up for it. The form registers its own tools with the browser, and the assistant writes through the same runtime calls the person's typing uses, so every rule, check and calculation runs as it would for them. Each change is outlined and read out and can be undone, and anything that leaves the page asks the person first. Signing, choosing a file and pressing Submit on a signed form have no tool. It is opt-in for the host and for the form's author. See Browser assistants.
Can a form be printed?
Yes. Print hands the browser's print dialog the form with its answers as text, a running header and footer, page numbers and a first-page title, as the form's print settings say. A live form prints by each field's own setting, so a blank printout still has every field someone may need to fill in by hand. Tabs, steps and collapsed parts print laid flat. See Print. For a file, generate the PDF instead.
Which PDF/A levels are supported?
2b, 2u, 2a, 3b, 3u and 3a, with tagging and embedded fonts. Under PDF/A-3 a layout can embed the record itself, and uploaded files can be attached in any PDF that is not PDF/A-1 or 2. See PDFs.
How are PDFs signed?
With PAdES. The server signs with its own certificate, or the person signs through a small local agent with a certificate of their own: one stored on their machine as a file, or one on a YubiKey. A YubiKey is not required. With a YubiKey, the PIN stays in the operating system's own dialog.
What is a submission, and how is it signed?
A submission is what the form sends when a person presses submit: the answers as a JSON envelope, in a canonical form so the same answers always give the same bytes (Concepts defines the words). It is the data; a PDF is a document made from it, and the two are signed separately. A PDF signature (PAdES, above) proves the document has not changed since it was signed. A submission signature proves who sent exactly these answers: a passkey or security key signs the canonical bytes with WebAuthn, and the server recomputes the challenge and reports every check on its own, so a failed verdict says exactly why. A form can use either signature, both, or neither. See Signing.
Can a person save and come back later?
Yes. Drafts save as the person types: to browser storage on the person's own machine, to your server, or to a store your page writes, such as a file the person keeps and restores from later. A draft is restored only into the same form, at a schema version it can read. See Drafts.
Can a form be in more than one language?
Yes. Every label, message and option is text per locale, edited in the builder's translations grid, and switching language never resets an answer. The printed page and the PDF follow the same locale, and right-to-left locales set the direction. See Languages.
Can every form carry our header, footer and logo?
Yes. Form chrome is a logo, the organisation's name, a title, text and the language switcher, in the header or the footer. A host can set it once, as defaults or as overrides, for every form the page serves, and a form's own definition can carry the same parts; a host does not have to provide any of it, and where both exist they are merged with one switcher. The background is a frame the binding draws: seamless in the page, outlined, or paper. The demo's Form chrome menu shows each. See Look and chrome.
Can I match my own design system?
Yes, two ways. Datum's own look is tokens plus a stylesheet scoped to the form, and a host restyles it with create (tokens, a dark set, frames, parts), set as the form's binding. To draw a form in a design system's own markup and components, a host registers a binding. Nine reference bindings (the GC Design System, GOV.UK Frontend, USWDS, Bootstrap, Nova Scotia, Alberta, Québec, Ontario and Fluent UI) show how; they are references and starting points, with no support promise and no accessibility claim from Datum. Your own component types render and print alongside the built-in ones. See Look and chrome and Design-system bindings.
How do we govern thousands of forms?
As files. A form is one JSON document, so it goes through the review and approval you already use for code or documents: keep it in your own repository, see every change as a diff, and publish the version you approved. Your server registers each form by id and version, accepts a submission only for a version it has, and keeps each record under the version it answers, so anyone checking later can open the exact form a person saw. See The definition.
Where does the data live?
Wherever you put it. Storage, keys and the PDF renderer are seams you bind in your host. When you run the submissions service, its export route returns a form's accepted records as CSV, one column per field, or as JSON.
Which browsers does it need?
Datum names no browser versions; it states what the code needs. The bundles are built for ES2020 (the PDF page-imagery module for ES2022) and load as modules, or as classic scripts for the form and builder. The elements use custom elements and shadow DOM. The renderer's styles use color-mix(), container queries and :has(), and the builder uses dialogs. The sandbox and the PDF program need WebAssembly. Passkey signing needs WebAuthn, and local drafts need local, with an in-memory fallback where it is refused. Without WebAssembly there is no in-page sandbox, so a form is validated by the server alone; without WebAuthn there are no passkey signatures. Assistants need a browser with WebMCP. Test the browsers you must support before you commit to them.
What licence is it under?
Datum's own code is under the MIT licence. The LICENSE file is in the repository and in the offline bundle.
What third-party terms come with the files?
The files you serve include material that keeps its own licence, listed in THIRD_ in the repository, and copied into the offline bundle with LICENSE. In the bundle folder:
| What | Terms |
|---|---|
fonts/, embedded in PDFs | DejaVu Fonts License |
pdfjs/, the template page imagery | Apache-2.0, with the licences of its bundled data beside it |
builder-fonts/, Geist and Geist Mono | SIL Open Font License 1.1, with the text in the folder |
| The icons of the Font Awesome plugin | Font Awesome Free: icons CC BY 4.0, which asks for attribution, and code MIT |
The sandbox module, CodeMirror, bidi-js and the PDF libraries bundled in the programs | MIT, with Unicode data under the Unicode licence |
The bundle folder itself holds no licence file, so carry the notices with what you serve. The reference design-system bindings pin their design systems as development dependencies and never bundle them; their releases, fonts and marks keep their own terms, which the notices list.
Is Datum released?
Not yet. Datum is pre-release, at version 0.1.0, and nothing is published to npm, Maven Central or PyPI, so for now you build from the repository. The definition format and the program contracts can change without notice, and only main is supported. There is no changelog yet.
Versions today:
| What | Version | Where it shows |
|---|---|---|
| Packages | 0.1.0 | Every package |
| Sandbox program interface | 4.1.0 | Running the programs on your own server |
| PDF program interface | 4.0.0 | The same table |
schema of a definition | any non-empty string; the examples use "1" | The definition |
The major number of an interface changes when a payload's shape breaks, and a host refuses a program built for another major. A schema is compared for equality when a draft is restored, and nothing migrates a definition from one to another. Deploy servers first or together with the browser bundle.
Where do I get help?
Read the source and the pages of this site, which mirror what the code does. Report a bug or ask a question as an issue on the project's repository. Report a vulnerability privately through the repository's security advisories, and never in a public issue: SECURITY. in the repository says how.