In plain English
A machine that turns your data into finished documents
No jargon on this page. Just what Wraft does, why the old way hurts, and what changes when documents stop being typed and start being generated.
Why this hurts
Most document work is the same work, done again
Nothing here is anyone's fault. It is what happens when the document is the source of truth instead of the data behind it.
The same document, typed again
Someone copies last quarter's proposal, swaps the name and the numbers, and hopes they caught every one.
Formatting drifts
Twelve people, twelve versions of the same template. The logo moves. A clause goes missing.
Nobody knows which is current
Three files with similar names in three places, and the signed one is in someone's inbox.
The simple version
Four things, in order
If you remember one picture from this page, this is the one. Everything after it is detail.
How it works, plainly
The same pipeline, with the steps named
Each stage hands off to the next. Any stage can be re-run on its own without losing what came before it.
The only two words that matter
A template is not a document
Almost every misunderstanding about Wraft comes from these being treated as the same thing. They are not, and keeping them apart is the whole trick.
The template
Written once, by whoever should own it
Legal writes the clauses. Design sets the layout. The parts that change — a name, a date, a total — are marked as fields rather than typed in. Nobody edits the template to make a document.
The document
Generated, not copied
Wraft takes one record, fills the fields, and typesets a finished PDF. Do it for one client or four hundred; the formatting is identical because it came from the same template.
Built in, not bolted on
Why this beats stitching four tools together
The alternative is a writing tool, a signing tool, a storage tool, and a spreadsheet holding it together. Each handoff is a place where a document goes wrong.
Signing is part of it
Not a separate tool with a separate bill. Send for signature from the document you just generated.
Every step is recorded
Who changed what, which version was approved, when it was signed. Not reconstructed from email.
It runs where you put it
Your servers, your storage, your rules. Open source under AGPLv3, so leaving is always possible.
Every step is tracked
You can always answer 'which version was signed?'
Not by searching an inbox. Each stage records what happened and against which revision, so the answer is a lookup rather than an investigation.
- 01 The record arrives From a form, an import, or an API call.
- 02 The document is built Stamped with the template version that produced it.
- 03 Review happens in order Each approval is tied to the revision it approved.
- 04 The signature seals it After that the artifact is immutable and verifiable.
What this means in practice
Where teams put it to work first
Sales proposals
Pull the deal from your CRM, generate the proposal, send it for signature. Minutes, not an afternoon.
Employment paperwork
One offer letter template, one row per hire. Consistent terms, correct names, an audit trail by default.
Product catalogs
Thousands of items from a spreadsheet into a typeset catalog, rebuilt whenever the data changes.
Compliance reporting
The same report every quarter, from the same template, with every revision retained and diffable.