Create a Template

A template is a Word .docx plus a tag configuration that, together, generate a contract. You usually start from an agreement your organization already uses, mark up the places that change from deal to deal, and let Pactly fill them in at generation time.

Template authoring happens in the Pactly Word plugin, in its Templates area, not in the web app. Building the .docx, tagging it, and parsing the tags all happen in Word. The web app’s Manage Templates screen is a lighter admin view, and end users only ever generate contracts from a finished template. See The Pactly Word Plugin for how to install and sign in.

Creating a template is currently a master-admin task, handled during onboarding by the Pactly team. If you need a new template or a change to an existing one, raise it with your Pactly contact. This article documents how the work is done so you understand what is involved.

Building a template is four moves, regardless of the agreement type:

1. Prep the source document. Take the existing .docx and clean it up so Pactly can parse it reliably (fonts, content controls, hyperlinks, see below).
2. Embed tags. Mark each spot that changes per deal with a Pactly tag (a variable, a conditional clause, a party field, a value map).
3. Parse. Pactly reads the tags out of the document and builds the configuration (the list of variables, value maps, rules, party fields, and so on).
4. Map and upload. Connect each discovered tag to a contract property or define its choices and rules, set the template’s category and other settings, then save and upload the .docx.

The result is a template that produces a contract in Draft status every time it runs.

Most templates start from a Word document a customer already has, often migrated from another tool. Pactly does not clean these up for you, so a few things have to be fixed by hand before tagging, or the output document comes out wrong.

Tagging is where you mark the parts of the document that change. Pactly’s tags are double-brace, camelCase tokens you type directly into the Word document. A few of the most common:

• A variable like {{contractValue}} is replaced with a value at generation time.
• A conditional clause wraps text you want to show or hide: {{if hasNda}}...{{/if}}.
• A party field like {{party1.entityName}} pulls an attribute from a party on the contract.
• A value map like {{vm services}} renders the text of a dropdown selection.

The full tag vocabulary, the block-versus-inline rules, and the hard limitations live in the variables and tokens reference (a sibling article in this section). The key point for authoring: tags are plain text in the .docx, and any tag you mistype or leave unmapped renders as a [●] marker in the output rather than failing the generation.

With the document tagged, the rest happens in the plugin’s Templates area. The flow below shows the screens involved. Because these are Word task-pane screens, they cannot be captured from a browser, screenshots will be added from Word.

Once a template is uploaded and clean, end users generate contracts from it in the web app, typically by filling out an intake form rather than by picking the template directly. The generated contract enters the repository in Draft, with its category inherited from the template and its variables filled from the form responses.

To wire a form to a template so submissions generate a contract automatically, see the Forms section, in particular Form Actions and Field Mappings and Naming.

• Templates Overview
• The Pactly Word Plugin
• Form Actions
• Field Mappings and Naming
• Create a Contract