Document templates

A document template is a reusable Markdown body that seeds a new document. When someone authors a policy or a procedure, the editor offers the templates matching that document’s type and language, so people start from your house structure instead of a blank page — and every policy that comes out of the process has the same sections in the same order.

Where to find it

Catalog → Document templates in the sidebar.

Key concepts

Built-in and custom

Built-in templates ship with the platform — a library of common security policies — and are read only. You can open and preview them, but not edit or delete them. They are visible from every domain.
Custom templates are yours. Create them in the application or import them in bulk, edit them freely, and delete them when they are superseded. A custom template is scoped to the domain you create it in.

Opening any template shows a rendered preview of its content, and a badge marks the ones that ship with the platform.

Fields

Field	What it does
Reference	The stable identifier; locale variants of the same template share it
Name	What the picker shows
Description	Free text — what this template is for
Document type	Policy, Procedure, Charter, Record, Meeting minutes or Other
Language	Which locale this variant is written in
Provider	Free-text attribution such as CIS or NIST
Domain	Scope for custom templates

Document type and Language are not decoration: together they decide which templates the editor offers when a document of that type is being authored in that language. A template with the wrong type is invisible at the moment it is needed.

Creating one

Choose Add document template and set its reference, name, document type, language and optionally a provider. The body is written afterwards, on the template’s own edit page, in the same Markdown editor with toolbar and preview that documents use. Keeping the body off the creation dialog is deliberate — long content is easier to write where there is room for it.

For a single template this is quicker than assembling a one-file archive.

Importing in bulk

Import templates uploads a .zip of Markdown files and creates one custom template per file. The archive mirrors the built-in library layout, with one folder per language:

templates.zip
├── en/
│   ├── access_control.md
│   └── incident_response.md
└── fr/
    └── access_control.md

Two conventions do most of the work: the immediate parent folder is the language, and the filename becomes the reference — so access_control.md becomes the reference access_control. Optional YAML frontmatter at the top of each file sets the rest:

---
title: Access Control Policy
description: How access to systems is granted and reviewed
document_type: procedure
locale: en
provider: CIS
---

Every key is optional. title defaults to the title-cased filename, document_type is validated against the built-in types and defaults to policy, and locale acts as a fallback for a file sitting at the archive root rather than inside a language folder — a language folder always wins over it. Everything after the frontmatter is the template body.

Re-importing the same reference and language updates the existing custom template instead of creating a duplicate, so an archive can be treated as a source of truth you push repeatedly.

Browsing and cleaning up

The list filters by Document type, Language, Builtin and Domain, with a text search across the rest. To remove templates in bulk — after a bad import, for instance — select the rows and use the batch delete action; any built-in templates caught in the selection are protected and left alone.

When authoring a document, the template picker gains a search box once there are enough templates to warrant one, matching on title, description and provider.

Documents — where templates are actually used.
Frameworks — the requirements your policies answer to.
Libraries — other catalog content loaded the same way.