# Workflows Crash Course
Source: https://helpdocs.gavel.io/docs/gavel-101/workflow-video-series
## About this lesson
This video gives a quick overview of Gavel workflows and document automation.
## Dashboard Overview
Get a better understanding on how to navigate the Gavel Workflows Dashboard.
## Adding Logic to Questions and Pages
Make your questionnaire dynamic by using question and page logic.
## Repeating Item Lists
Collect sets of data in Repeating Items, where you need information on items and do not know how many of those items may be needed.
## Loading the Document Tagger Word add-in
Connect your questionnaire to your Word templates in order to tag the template with your new variables.
## Setting up Word documents
Make your templates dynamic by using conditional logic with the Document Tagger.
## Repeating Item Deep Dive
Learn how to tag your Word templates for Repeating Items
## Tagging fillable PDFs with Blueprint the AI Workflow Generator
By using Gavel Blueprint, you can quickly scan and tag your fillable PDFs into quick and easy Workflows.
## Tagging PDFs with PDF Tagger
Directly Tag your fillable PDFs in the Gavel PDF Tagger.
## Adding Logic to Generated Documents
Use Document Logic to decide which documents will be generated based on answers provided in the questionnare.
## Creating Client-Facing Workflows
Create Questionnaires that will be dynamic and easy to use for your clients.
## Connect Clio to your internal workflows
Connect your Clio Matter and Clio Contact Cards to Gavel to minimize repetative data inputs.
## Using Data Manager
Use the internal Gavel Data Manager to review and edit your client sessions, and even reuse the data from workflow to workflow.
## Look-Up Tables, CSVs, and Spreadsheets.
Use the CSV question type to pull data sets from your spreadsheets.
# Batch Analysis: Generate a Comparative Table and Memo
Source: https://helpdocs.gavel.io/exec/batch-analysis
Turn a set of contracts into an interactive spreadsheet—extract terms, compare clauses, and spot inconsistencies across multiple files at once.
## Overview
Batch Analysis in Gavel Exec for Web transforms a set of contracts or documents into a structured, interactive spreadsheet. Each document becomes a column, and each specific term becomes a row, making it possible to extract key terms, compare clause language, and identify inconsistencies across large document sets in a single workflow.
Batch Analysis is built for high-volume legal work where reviewing contracts one at a time is not practical.
Batch Analysis is available in **Gavel Exec for Web**. It is not available in the Word add-in.
***
## What It Does
Upload a set of contracts and Gavel Exec returns a structured table where:
* **Columns** represent individual documents
* **Rows** represent AI-generated extractions based on your prompts
From the spreadsheet view you can:
* Extract specific terms (payment amounts, notice periods, governing law, renewal provisions)
* Compare how a clause is handled across different agreements
* Flag inconsistencies in language or missing provisions
* Draft memoranda on major issues across the full document set
***
## How to Run a Batch Analysis
In **Gavel Exec for Web**, open the Batch Analysis feature and upload the contracts you want to analyze.
Click on "Auto-detect fields" to allow the AI to generate various fields you want to extract from the contracts. You can also add your own fields separated by a comma.
Each field becomes a row in the output spreadsheet.
Gavel Exec processes each document against every prompt. The hybrid search layer locates the relevant provisions—whether they use the same words, similar language, or structurally equivalent clauses.
The results appear in a table. Click into the cell and open a sidebar that shows the source language in the original document.
Export the table for use in due diligence reports or click "Draft Analysis" to generate a memorandum on major issues drawn from the full document set.
You can also edit the Draft Analysis prompt to cover specific aspects of the Batch Analysis as needed.
***
## Common Use Cases
| Use Case | What You're Looking For |
| ------------------------- | -------------------------------------------------------------------------------- |
| Due diligence | Key terms, reps and warranties, material conditions across a deal's document set |
| Lease portfolio review | Rent escalations, expiration dates, renewal options, landlord obligations |
| Vendor contract audits | Liability caps, indemnification positions, data processing terms |
| Policy compliance reviews | Consistency of required provisions across a contract population |
| NDA triage | Scope, carve-outs, survival periods, permitted disclosures |
***
## Generating a Memo from Batch Results
After running a Batch Analysis, Gavel Exec can draft a structured memorandum summarizing major issues across the document set. The memo can be adjusted to include basics or other specific language you would like it include, such as:
* References the source documents with citations
* Organizes findings by issue or clause type
* Flags the most significant deviations or risks across the population
This is particularly useful for delivering due diligence summaries, portfolio reviews, or compliance audits to clients or senior stakeholders.
***
# Gavel Exec Certification Course
Source: https://helpdocs.gavel.io/exec/certification-course
Become a certified Gavel Exec user through our online course on Gavel University — learn best practices, advanced features, and earn your certification.
## Get Certified in Gavel Exec
Level up your skills with the **Gavel Exec Certification Course** on Gavel University. This self-paced course walks you through everything you need to confidently use Gavel Exec in your day-to-day legal work — from setup to advanced contract review workflows.
Visit Gavel University to start the course and earn your certification.
## What you'll learn
* How to install and configure Gavel Exec in Microsoft Word and on the web
* Best practices for using Quick Actions to redline, draft, and review contracts
* How to leverage Chat Mode, Playbooks, and Projects for firm-specific AI
* Tips for sharing Playbooks and Projects across your workspace
* Real-world use cases and example workflows from practicing attorneys
## Why get certified
* **Build confidence** using Gavel Exec across your contract workflows
* **Save time** by learning the fastest path to common tasks
* **Showcase your expertise** with an official certification from Gavel
The certification course complements the [Video Series](/exec/video-series) and written documentation. Use it as a structured way to onboard yourself or your team.
Watch short tutorials covering Gavel Exec's main features.
Have questions about the course? Reach out to the Gavel team.
# Chat Mode
Source: https://helpdocs.gavel.io/exec/chat-mode
Use Chat Mode to ask questions, summarize clauses, draft new language, generate redlines, and evaluate counterparty changes — from within Microsoft Word or on Web Exec.
Gavel Exec Chat works best when it has context beyond the contract you have open in Word. Uploading a reference file — a letter of intent, a term sheet, a prior redline, or a comparable executed agreement — gives the AI a second document to work with. It can compare the two, check for consistency, flag deviations, or use the uploaded file's language and structure as a model when drafting or redlining your agreement.
File uploads in Chat are session-scoped: they apply to the current conversation and are not automatically available in future chats. If you need a document to be present in every session for a given matter, use [Projects](/exec/projects) to attach it permanently.
## What you can upload
Use Chat file uploads for reference material that is specific to a particular task or question:
* A letter of intent or term sheet to check whether your agreement's terms match what was negotiated
* A prior draft of the same agreement to compare how a provision has evolved
* Deal notes or a memo explaining the client's agreed positions
* A comparable executed agreement to use as a drafting model
* A counterparty's redline to understand their markup before responding
The uploaded file becomes part of the conversation context. Gavel Exec treats its contents as reference material when responding to your prompts for the duration of that chat session.
## How to upload a file
With your contract open in Word, activate the Gavel Exec panel and start or open a Chat session.
Use the file upload control in the Chat panel to select the document you want to add as reference material. Gavel Exec processes the file and confirms it is available for the session.
Reference the uploaded document in your prompt. For example: "Redline this agreement based on the uploaded LOI" or "Flag any inconsistencies between this contract and the attached term sheet."
Gavel Exec incorporates the uploaded file into its analysis and response. If it proposes redlines, review them in the Chat panel and click **Apply All** to push them into your Word document as tracked changes.
Uploaded files apply to the current Chat session only. If you close the session and start a new one, you will need to upload the file again if you want to reference it. For permanent, session-persistent reference documents, add them as Project Files instead.
## Example prompts using uploaded files
"Redline this agreement to reflect the terms in the uploaded LOI. Flag any provisions that deviate from what was agreed."
"Make sure the financing terms in this agreement align with those in the attached term sheet, and suggest redlined changes where they diverge."
"Draft a limitation of liability clause in the same style and using the same defined terms as the uploaded executed agreement."
"Compare the indemnification clause in this document to the version in the uploaded prior draft and explain what changed."
## Ad-hoc uploads vs. Project files
Both approaches let Gavel Exec reference external documents, but they serve different purposes.
| | Chat file upload | Project files |
| ------------------ | -------------------------------------------- | ---------------------------------------------------- |
| **Scope** | Current chat session only | All chats within the Project |
| **Best for** | One-off references specific to a single task | Ongoing matter context available across all sessions |
| **Persistence** | Expires when the session ends | Permanently attached to the Project |
| **Setup required** | None — upload directly in Chat | Requires creating a Project and adding files |
Start with ad-hoc uploads when you are still exploring what reference material is useful for a matter. Once you identify the documents you consistently refer to, move them into a [Project](/exec/projects) so they are always available without re-uploading.
# Contact Gavel Exec Support
Source: https://helpdocs.gavel.io/exec/contact-us
Reach the Gavel Exec team by email, phone, or scheduled call — get help with setup, billing, or any questions about using the add-in.
The Gavel Exec support team is available to help you with installation, billing, feature questions, and anything else you need. Choose the contact method that works best for you.
Send a message to **[exechelp@gavel.io](mailto:exechelp@gavel.io)** and the team will get back to you as soon as possible.
Reach us by phone at **(415) 941-6866** during business hours.
Schedule a 30-minute call with the Gavel Exec team to walk through your questions or get hands-on help.
Have a feature idea or a suggestion for improving Gavel Exec? Share it on the [Wishlist](/exec/wishlist) page — the team reviews every submission.
# Install Gavel Exec Add-In for Word
Source: https://helpdocs.gavel.io/exec/installation
Add the Gavel Exec add-in to Microsoft Word from Microsoft AppSource, set up your account, and troubleshoot common deployment errors.
## Set up your account
Go to [exec.gavel.io](https://exec.gavel.io/) to create or sign in to your Gavel Exec account. Once signed in, you will be in the Exec on the Web and can begin utilizing Exec. To be able to redline specific documents and create playbooks, projects, etc., you will need to use the Microsoft Word add-in.
## Install the add-in
You have three options to get Gavel Exec into Microsoft Word:
In a Word Template, go to **Home Ribbon** → **Get Add-Ins** (labeled **Office Add-ins** in some versions of Word)
![Step2 Add Ins Pane D Iew WQ Zh]()
In the search bar, type **Gavel Exec** and select the result.
Click **Add** to install the add-in. The Gavel Exec panel will appear in the right-hand side panel of Word.
Go to [word.new](http://word.new) and open or create a document.
On the Home tab, click Add-ins (right side of the ribbon).
![Step2 Add Ins Pane D Iew WQ Zh]()
Type Exec in the search box. Alternatively, click More Add-Ins and search the Microsoft Store directly.
![Step3 Gavel Exec Add I Zm X4t XE]()
Click Add next to Gavel Exec, then sign in with your account.
![Step4 Add Then Sign In C Nz Zion]()
Visit the [Gavel Exec listing on Microsoft AppSource](https://appsource.microsoft.com/en-us/product/office/WA200008441?tab=Overview) and click **Get it now** to add it to your Microsoft 365 account.
## Troubleshooting deployment errors
If you see an error when trying to install or load the add-in, work through the options below.
If you encountered an error installing from a browser, open Microsoft Word and use **Home Ribbon** → **Get Add-Ins** (or **Office Add-ins**) to install Gavel Exec directly from within the application instead.
Cached data from a previous session can interfere with the installation flow. Clear your browser cache or open a private/incognito window and attempt the installation again.
If your organization manages Microsoft 365 centrally, an admin may need to enable the add-in:
1. Sign in to the [Microsoft 365 Admin Center](https://admin.microsoft.com/).
2. Go to **Settings** → **Integrated Apps**.
3. Verify that app deployment is enabled and that Gavel Exec is not blocked.
This step requires Microsoft 365 admin privileges. Contact your IT administrator if you don't have access.
If the add-in loads but behaves unexpectedly, clearing Word's add-in cache often resolves the issue:
1. In Microsoft Word, go to **File** → **Options** → **Trust Center** → **Trust Center Settings**.
2. Select **Trusted Add-in Catalogs**.
3. Check the box labeled **Next time Office starts, clear all previously-started web add-ins cache**.
4. Click **OK**, close Word fully, and restart it.
If none of the troubleshooting steps resolve your issue, contact Gavel support through the [Contact page](/contact).
# What Is Gavel Exec?
Source: https://helpdocs.gavel.io/exec/introduction
Gavel Exec runs inside Microsoft Word and on the web, letting attorneys analyze, redline, and draft contracts using AI trained on transactional legal language.
Gavel Exec is the AI-powered suite built for transactional attorneys. It runs as a panel inside Microsoft Word **and now on the web at [exec.gavel.io](https://exec.gavel.io)**, so you get accurate, legally-trained contract analysis and redlining wherever you work — without switching applications. Whether you're reviewing a first draft, responding to counterparty redlines, benchmarking a clause against market standards, or running batch analysis across a portfolio of contracts, Gavel Exec helps you work faster and more consistently on every deal.
## How Gavel Exec works
Gavel Exec is available on two surfaces. Your projects, playbooks, and context carry across both.
* **Gavel Exec for Word** — A panel that runs inside Microsoft Word. Draft, redline, and review contracts without leaving your document.
* **Gavel Exec for Web** — A full-featured legal AI platform at [exec.gavel.io](https://exec.gavel.io). Access all Word add-in capabilities plus web-only tools like Batch Analysis, Market Benchmarking, and multi-document review.
All current users have access to both surfaces under their existing plan.
Within each surface, Gavel Exec operates in two primary modes. You can switch between them depending on the task at hand.
* **Chat Mode** — Talk to Gavel Exec like an assistant. Ask it to redline, draft, summarize, or flag legal issues in the open document through a conversational interface.
* **Playbook Mode** — Apply a structured set of rules to review and redline a document. Use Gavel's built-in playbooks or create your own to enforce consistent positions across every deal.
Both modes support **Projects**, which let you attach firm-specific documents and standing instructions so the AI always operates with the right context for a deal.
## Key use cases
### Available in both Word and Web
**Asking questions and getting summaries**
Ask Gavel Exec to explain terms, surface risks, or summarize any section of the document.
* "What are the key obligations in this section?"
* "Summarize the indemnification clause in client-friendly terms."
* "Which clauses relate to termination?"
**Revising clauses or drafting new language**
Highlight text and ask Gavel Exec to rewrite or improve it using legally-trained, domain-specific AI.
* "Make this clause more buyer-friendly."
* "Draft a limitation of liability clause in the same style as this paragraph."
**Redlining documents**
Generate redlines based on specific instructions or reference documents. Proposed redlines appear in the chat for your review — use **Apply All** to accept them, then accept or reject individually in Microsoft Word.
* "Redline this clause to reflect seller-side positions."
* "Apply redlines consistent with a strong investor preference."
**Evaluating counterparty redlines**
Use the **Summarize Redlines** Quick Action to review accepted redlines, then ask Gavel Exec whether to accept, reject, or counter each one.
**Long-form drafting**
Draft documents from scratch or from a precedent, grounded in legal data and market standards.
### Available in Gavel Exec for Web
**Batch Analysis**
Run analysis on key terms across a stack of contracts and get a structured, tabular view of the results. Built for due diligence, lease portfolios, vendor reviews, and policy audits. Can also draft memoranda summarizing major issues.
**Market Benchmarking**
Benchmark a clause or an entire document against market standards across corporate transactional and commercial contract categories, with segmentation by industry and company size.
**Multi-document analysis**
Drop in multiple documents at once and get comparative analysis across them, with citations back to each source.
## Adding context to your prompts
You can attach additional context to any prompt by clicking the **+** button in the bottom-left of the Exec chat window:
* **Upload a file** — Add a related document (such as an LOI or term sheet) to give the AI more background on your deal.
* **Scope to selected text** — Highlight text in the document first, then select this option to limit changes to that selection.
In Gavel Exec for Web, you can also drop in multiple files at once for comparative review.
## Using Projects
At the top of the chat panel, you can select or create a **Project** to scope Chat Mode and Quick Actions to a specific deal. Projects attach multiple documents and standing instructions so the AI always has the right context — useful for recurring clients or complex transactions. Projects are accessible across both the Word add-in and the web platform.
Ask questions, summarize clauses, and request redlines through a conversational interface.
Apply consistent, rule-based redlines using built-in or custom playbooks.
Attach firm-specific files and instructions to give the AI deal-level context.
Use guided Quick Actions to redline, comment, draft, and find missing terms.
Run structured analysis across a portfolio of contracts in a tabular view.
Benchmark clauses and documents against market standards by industry and company size.
# Market Benchmarking: Comparing Contracts against Market Standards
Source: https://helpdocs.gavel.io/exec/market-benchmarking
Compare contracts against market standards to instantly identify off-market, missing, or weaker terms.
## Overview
Market Benchmarking in Gavel Exec allows you to compare a contract against recognized market standards. It surfaces terms that are off-market, missing, or weaker than what you've negotiated before—before negotiations even begin.
Market Benchmarking is available in **Gavel Exec for Web**. It is not available in the Word add-in.
***
## What It Does
Market Benchmarking analyzes clause language at the provision level and flags deviations from typical commercial positions. This includes:
* **Liability limitations** — Is the cap in range for this deal size and sector?
* **Indemnification** — Are the obligations mutual, one-sided, or missing standard carve-outs?
* **Termination** — Do the triggers and notice periods reflect current market norms?
* **Payment terms** — Are net payment windows, late fees, and remedies standard?
Gavel Exec compares your document against standards across **corporate transactional and commercial categories**, with benchmarks filtered by industry and company size to give you context that's actually relevant to your deal.
Market Benchmarks are built into the product by Gavel's team of lawyers.
***
## How to Run a Market Benchmark
In the Gavel Exec for the Web, click on **Market** **Benchmarking**.
Select the Jurisdiction, Industry and Company Size.
Upload the contract you want to review in **Gavel Exec for Web**. This can be a PDF, Docx, or TXT
Gavel Exec returns a clause-by-clause analysis showing:
* Whether each provision is **on-market**, **off-market**, or **missing provisions**
* How your language compares to the benchmark
* Suggested redlines or alternative language where applicable
***
## Use Cases
**Negotiate from a stronger position** When off-market terms are identified early, you can enter negotiations prepared. Benchmarking gives you the data to make focused concessions and resist pushback on provisions that are clearly within market range.
**Flag missing clauses** Benchmarking doesn't just compare existing language—it identifies provisions that are absent from the contract altogether, such as a missing limitation of liability or omitted IP assignment clause.
**Calibrate by deal context** Gavel's benchmarks are segmented, so a mid-market SaaS acquisition is compared against relevant precedent—not a generic pool. This means the output is actionable, not just directional.
**Maintain consistency across your team** When combined with Playbooks and Workspaces, benchmarking helps ensure that every lawyer on your team is applying the same standards and flagging the same issues.
***
## Benchmarking vs. Playbook Review
A **Playbook review** applies your firm's specific requirements and preferred language to a contract—it tells you whether the contract meets your internal standards.
**Market Benchmarking** compares the contract to external market norms and precedent—it tells you whether the terms are commercially reasonable relative to the broader market.
Both features can be used together. Many teams run a Playbook review for internal compliance and then layer in Benchmarking to assess commercial risk and negotiation positioning.
Gavel's built-in benchmarks cover a wide range of corporate transactional and commercial agreement types, including MSAs, SaaS agreements, NDAs, employment agreements, real estate leases, and M\&A deal documents. Benchmarks are segmented by industry and company size where applicable.
# Playbooks: Apply Consistent Rules to Every Contract
Source: https://helpdocs.gavel.io/exec/playbooks
Use built-in or custom Playbooks to apply a structured rule set to any contract, enforcing consistent positions and flagging deviations across every deal.
Playbooks let you apply a defined checklist of rules to a contract in a single pass. Instead of writing a prompt each time, you build the rules once and run them against any document. Use Playbooks when you want the AI to enforce consistent positions — such as market-standard benchmarks or client-favorable terms — rather than handle open-ended judgment calls. For complex, multi-document review that requires broader deal context, see [Projects](/exec/projects).
## Built-in playbooks
Gavel Exec includes a library of built-in playbooks developed with expert attorneys in corporate and real estate law. You can run these immediately without any setup. Built-in playbooks cover:
* **Market-standard benchmarks** — Flag deviations from common market positions across standard agreement types.
* **Client-favorable positions** — Apply strong buyer or seller terms, depending on which side you represent.
## Build your own playbook
You can create a custom playbook by adding rules manually or by generating rules from your existing documents, such as checklists, spreadsheet playbooks, or prior finalized agreements.
Custom playbooks can include:
* Redlines
* Comments to opposing counsel
* Comments to your client for internal review
Go to the **Playbooks** tab in the Gavel Exec panel and click **+ Create new**.
Enter a name for your playbook and click **+Create**.
Choose one of two methods to populate your playbook:
Click **+Add rule**. For each rule, enter a description with as much detail as needed, including specific guidance on how the AI should approach redlining for that issue.
Click **Generate from Files** to create rules automatically from your existing documents.
You can upload **docx**, **PDF**, or **csv** files. From there, Gavel Exec will walk you through a short questionnaire:
Answer questions about what you want the playbook to accomplish.
Upload the documents that define the standards your playbook should enforce — for example, a checklist, a policy memo, or a prior negotiated agreement.
Upload template agreements or fully negotiated contracts you want the playbook to draw from when generating rules.
Gavel Exec converts the uploaded files into a set of reusable rules that apply consistent redlines across future deals.
## Running a playbook
Once your playbook is ready, you have two options for how to run it:
* **Run the entire playbook** — Apply all rules at once to the open document. Gavel Exec works through each rule and surfaces the results in the chat panel.
* **Run rules individually** — Select a single rule and run only that rule against the document. Use this when you want to focus on a specific issue or test a new rule before running the full set.
Both options give you an opportunity to **Run Playbook with Comments**. This allows you to generate comments based on the redlines that apply when you accept the redline. You can further narrow down the scope of the comments by selecting the commenting style:
**Flag negotiation risks for my side**
**Explain Key points/risks to my client**
**Generate counterparty-facing negotiation comments**
***
## Playbooks vs. Projects
**Playbooks** work like a junior associate following a checklist: they enforce a consistent set of rules, flag deviations from preferred language, and apply the same positions across every contract. They are best for issue spotting and policy enforcement.
**Projects** work like a senior associate: they bring in broader deal context from multiple documents and standing instructions, and handle more complex judgment calls — such as negotiation strategy, multi-document review, and custom redlines informed by prior drafts.
You can use both together. Run a Playbook for consistent rule enforcement, and use a Project in Chat Mode for the nuanced work that requires full deal context.
To learn more about setting up a project, see [Projects](/exec/projects).
# Projects: Deal-Level AI Context for Gavel Exec Chat
Source: https://helpdocs.gavel.io/exec/projects
Projects attach firm-specific files and instructions to Chat Mode so every prompt reflects your client's positions, preferred style, and deal history.
Projects are Gavel Exec's customization layer. When you work inside a Project, you give the AI your firm's actual context: the prior drafts you rely on, the positions your client will not move from, and the instructions that reflect how you practice. Every chat you run within a Project draws on that context automatically, so you do not have to re-explain your client's situation or your preferred approach with every prompt.
A Project turns Gavel Exec from a general legal AI into something that understands how your firm handles a specific deal type, client, or practice area. Small law firms can use Projects to build AI that actually reflects how they practice law — no engineering team required.
## The two components of a Project
Every Project has two building blocks.
Documents and data you want the AI to draw from: prior drafts of the agreement, deal notes, templates, prior redlines, legal background memos, or any other files relevant to the matter. Gavel Exec indexes these files and uses them as reference material in every chat within the Project.
The core positions, rules, and preferences you want the AI to follow. For example: "The client will not accept uncapped indemnity exposure," "Governing law must be Delaware," or "Use the tone and defined terms from the attached template." Instructions are applied to every prompt you make inside the Project.
## How Projects make chat context-aware
Once you open a chat inside a Project, every prompt you send is already informed by your Project Files and Project Instructions. You do not have to re-state the client's positions or paste in prior language. Gavel Exec operates with that context built in.
For example:
* If your Project Instructions specify that the client will not accept uncapped indemnity exposure, and your Project Files include a prior draft with approved carveout language, Gavel Exec takes both into account when redlining an indemnification clause. It will not suggest language your client has already rejected, and it can replicate the carveout structure your team has already agreed to.
* If you upload a prior executed agreement as a Project File and instruct the AI to draft in the same style, it uses that agreement's defined terms, sentence structure, and clause architecture as a reference when drafting new provisions.
This is the difference between asking a generic AI to redline a clause and asking an associate who has read the entire file.
## Setting up a Project
In the Gavel Exec panel, navigate to the **top of the tab** and click on the Sources block. Click on the "+ Create" to create a Project. Give it a name that identifies the matter or client.
Upload the documents you want Gavel Exec to reference: prior drafts, templates, deal notes, term sheets, or any background files relevant to the matter. You can add multiple files.
Write out the positions and rules you want the AI to follow for this Project. Be specific: define the client's hard limits, preferred language for key provisions, and any stylistic requirements.
Begin your chat session. Every prompt in that session draws on your files and instructions automatically.
Project files are permanent reference material available in every chat within that Project. This is different from uploading a file in a standard Chat session, which applies only to that single session. See [Upload reference files](/exec/chat-mode) for more on ad-hoc uploads.
## Playbooks vs. Projects
You need the AI to act like a **senior associate**: handling complex judgment calls, drawing on multiple documents, and performing deep review or negotiation with deal-specific context. Projects are best for matters where you have significant existing work product and a nuanced set of client positions that differ from deal to deal.
You want the AI to act like a **junior associate** applying a checklist: enforcing standard language, flagging deviations from policy, and running a consistent first-pass review across a class of contracts. Playbooks trade depth for consistency. [Learn about Playbooks](/exec/playbooks).
# Gavel Exec Quick Actions
Source: https://helpdocs.gavel.io/exec/quick-action-guide
Quick Actions are guided prompts that walk you through the inputs needed to redline, comment, draft, summarize, and find missing terms in your contracts.
Quick Actions make it easier to get results from Gavel Exec by guiding you through a short set of inputs rather than requiring you to write a full prompt from scratch. Each Quick Action is designed to produce a specific type of output — redlines, comments, a draft, a summary, or a list of missing terms — based on the parameters you provide.
To access Quick Actions, open the Gavel Exec panel in Microsoft Word and select the action you want from the Quick Actions menu.
## Available Quick Actions
The Redline Document Quick Action generates precise redlines throughout the contract or document based on the negotiation context you provide.
* **Negotiation Style** — Set how aggressive you want the redlining to be, from light-touch revisions to strong advocacy positions.
* **Representation** — Specify which party you represent so the AI redlines from the correct side of the negotiation.
* **Jurisdiction:** — Select Country, State/Province to hone into the jurisdictional specifications and language style for that area.
* **Additional Files** — Upload reference documents such as previous contracts or deal context materials to inform the AI's redlining style and substance.
* **Additional Instructions** — Add any specific focus areas or deal-specific requirements for the AI to prioritize.
![Screenshot 2026 04 20 At 10 01 26 AM]()
Proposed redlines appear in the chat panel for your review. Click **Apply All** to insert them as tracked changes in the document, then accept or reject each one directly in Microsoft Word.
The Add Comments Quick Action reviews the document and generates comments for you to review, add, or dismiss throughout the contract.
* **Representation** — Specify which party you represent so the AI comments from the correct perspective.
* **Comment Type** — Select the type of comments you want:
* **Flag negotiation risks for my side** — Identifies clauses that are unfavorable to your client.
* **Suggest redlines as comments** — Proposes specific language changes as inline comments.
* **Explain key points/risks to my client** — Generates plain-language explanations suitable for sharing with the client.
* **Jurisdiction:** — Select Country, State/Province to hone into the jurisdictional specifications and language style for that area.
* **Additional Instructions** — Add specific guidance for the AI to focus on particular issues or clause types.
![Screenshot 2026 04 20 At 10 02 30 AM]()
The Generate Draft Quick Action creates drafts of specific clauses, paragraphs, sections, or entire documents based on your direction.
* **Drafting Selection** — Describe what you want the AI to draft, such as a specific clause type, a missing section, or a full agreement.
* **Draft Placement** — Choose where in the current document the draft should be inserted.
* **Draft Tone and Style** — Select the style that fits the document:
* **Clear and concise** — Straightforward, plain language.
* **Detailed and explanatory** — More expansive language with context.
* **Other** — Specify a custom style.
* **Jurisdiction:** — Select Country, State/Province to hone into the jurisdictional specifications and language style for that area.
* **Additional Files** — Upload reference contracts or precedent documents to match your firm's drafting style.
* **Additional Instructions** — Add any additional requirements or constraints for the draft.
![Screenshot 2026 04 20 At 10 06 02 AM]()
The Use a Playbook Quick Action takes you directly to the **Playbooks** tab, where you can select a playbook to run against your document.
Playbooks apply a structured set of rules to review and redline the contract. You can use Gavel's built-in playbooks or create and save your own. See the [Playbooks guide](/playbooks) for full details on building and managing playbooks.
The Summarize Redlines Quick Action reviews the redlines in your document and generates a comprehensive outline of what those redlines change in the contract.
This is useful when you have received a redlined document from a counterparty and need a quick read on the overall impact of their proposed changes before negotiating. Open the redlined document in Word and run this Quick Action to get a structured summary in the chat panel.
After running Summarize Redlines, you can follow up in Chat Mode to ask whether to accept, reject, or counter each redline — and then have Gavel Exec insert those evaluations as comments or generate new proposed redlines.
The Find Missing Terms Quick Action searches the document for terms or provisions that are absent based on the baseline you set.
* **Identification Baseline** — Choose the standard the AI should compare the document against:
* **General market norms** — Common provisions expected in a standard commercial agreement.
* **Industry-specific norms** — Provisions typical in a specific industry.
* **Input your industry area** — Specify the industry for more targeted results.
* **Sample documents I provide** — Upload reference contracts to use as the baseline for comparison.
* **Jurisdiction:** — Select Country, State/Province to hone into the jurisdictional specifications and language style for that area.
* **Output Type** — Choose how you want the findings presented:
* **List of bullet points** — A plain list of missing terms.
* **Redlines with suggested alternative language** — Proposed additions inserted as tracked changes.
* **Comments explaining deviations** — Inline comments describing each gap.
* **Additional Instructions** — Add specific guidance on which terms or clause types to prioritize.
![Screenshot 2026 04 20 At 10 08 54 AM]()
All our Quick Actions can also be done directly in your chat mode by prompting the system to do any of the above actions!
# Upgrade Your Gavel Exec Plan
Source: https://helpdocs.gavel.io/exec/upgrading
Switch to a paid Gavel Exec plan at $160 per month — complete the upgrade in three steps directly inside the add-in.
The paid Gavel Exec plan gives you 1,000 queries for \$160 per month. You can upgrade at any time directly from inside the Word add-in — no separate billing portal or account page required.
## How to upgrade
Open the Gavel Exec panel in Microsoft Word and click the **Gear** icon to open your account settings.
In your account settings, click the **Upgrade** button to begin the checkout flow.
Review your selected plan, then enter your payment details to complete the upgrade. Your upgraded access activates immediately after checkout.
If you have questions about billing or your subscription, [contact the Gavel Exec support team](/exec/contact) — they can help you with invoices, plan changes, and payment issues.
# Gavel Exec Video Series
Source: https://helpdocs.gavel.io/exec/video-series
Watch video tutorials covering how to get started with Gavel Exec, including the AI Tutorial Introduction and what's new in recent updates.
## Gavel Exec Video Tutorial
## Intro to Gavel Exec
Our CEO, former Sidley Austin attorney, Dorna Moini, covers the main features in Gavel Exec.
## Gavel Exec for the Web
Director of Customer Success, Tricia Duffin, covers the main features in Gavel Exec for the Web.
## Gavel Exec Setup
How to load Gavel Exec to your Microsoft Word account.
## Workspace and Sharing
See how Workspaces in Gavel Exec help you securely share Playbooks and Projects with your team or clients. This short demo walks through how to manage users, control access, and keep your AI organized and consistent across your documents.
## Intro to Redlining
In this tutorial, we'll explore the core functionalities of Gavel Exec's Chat feature, designed to be your righthand on your legal drafting and review process. With Chat, you can easily redline agreements to identify risks and suggest modifications, revise specific clauses for clarity or precision, and analyze entire contracts to pinpoint potential ambiguities and obligations.
We'll show how to use targeted prompts to request redlines that align with your firm's playbook, ask for clause revisions that maintain legal intent while simplifying language, and generate comprehensive contract analysis to quickly assess key terms and areas of concern.
Whether you're negotiating a consulting agreement, updating a confidentiality clause, or reviewing a complex contract, Gavel Exec's Chat feature provides powerful tools to draft smarter and faster, all from within your document workspace.
## Uploading Files to Chat
In this tutorial, we'll walk you through how to load reference files in Gavel Exec to enhance the accuracy and relevance of AI-generated suggestions. By uploading key documents, such as templates, past agreements, or specific contract clauses, you can guide Gavel Exec to tailor its responses based on your preferred language, style, and legal standards.
We'll cover how to upload files and effectively use them as reference materials during drafting, redlining, and contract analysis. Whether you're working on a complex consulting agreement, a real estate contract, or a confidentiality clause, leveraging reference files ensures that Gavel Exec's suggestions align with your established practices and legal frameworks.
## Playbooks Overview
In this tutorial, we walk you through how to use Playbooks in Gavel Exec, the AI-powered legal assistant for lawyers. Playbooks are predefined rule sets that help you run redlines on contracts, ensuring that the terms align with either market standards or your specific preferences.
Learn how to use Playbooks, choose from existing templates, or create your own tailored to specific contract types. Gavel Exec's Playbooks have been developed and tested by attorneys specializing in various areas of law, providing reliable, attorney-approved guidance for your document review process.Whether you're reviewing NDAs, consulting agreements, or real estate contracts, Gavel Exec's Playbooks allow you to automate redlines, reduce risk, and maintain consistency across your legal documents. Watch the full tutorial to see how to run a Playbook and streamline your review process with Gavel Exec.
## Generating AI Playbooks
Learn how to Generate Playbooks with Gavel Exec AI Playbook feature.
## Create Customizable AI in Word
Gavel Exec Projects gives small law firms something they've never had before: the ability to build AI that actually understands how they practice law.
By combining your own firm documents with detailed instructions, you can train Gavel Exec to follow your preferences, your playbook, and your voice. No engineering team required.
In this video, we'll walk through how to use the new Projects tab in Gavel Exec:
* Add Project Files like templates or prior work product
* Add Project Instructions to guide tone, clause preferences, and more
* Start chats that instantly apply your context
## Update Deal Docs With Term Sheet or LOI
See how Gavel Exec, the AI-powered legal assistant inside Microsoft Word, automatically redlines a Series Seed Stock Investment Agreement based on a VC term sheet. Generate a redlined agreement in minutes.
Learn more at [www.gavel.io/exec](http://www.gavel.io/exec)
***
## What's new in Gavel Exec Video Series
The [**What is New in Gavel Exec Video Series**](https://youtube.com/playlist?list=PLSmo1Z4k2ziQFAIHu-h0-TGgin7mjcfOP\&si=QVSMhPdo0Se_XJwS) covers the latest features and improvements to the add-in. Watch this to stay current on new Quick Actions, interface updates, and workflow enhancements as Gavel Exec continues to evolve.
The videos give you a fast visual overview, but the written guides go deeper on every feature. After watching, explore the [Quick Action Guide](/exec/quick-action-guide) and [AI Chat Mode ](/exec/chat-mode)pages for step-by-step instructions and full option details.
You can also visit our [**Product Updates Page**](https://www.gavel.io/resources/gavel-exec-updates) to review all the new releases as they come out!
Learn every Quick Action in detail — redlining, commenting, drafting, and more.
See how to use Chat Mode to ask questions, summarize clauses, and request redlines.
# Submit a Feature Request for Gavel Exec
Source: https://helpdocs.gavel.io/exec/wishlist
Submit feature requests and suggestions to help shape the future of Gavel Exec — the team reviews every idea and uses your feedback to guide development.
Your feedback shapes what Gavel Exec builds next. If there is a feature you wish existed, a workflow you want improved, or an idea that would make the add-in more useful for your practice, submit it on the wishlist. The Gavel Exec team reviews every suggestion.
Visit the Gavel Exec Wishlist to share your ideas, vote on suggestions from other users, and track what the team is working on.
## Explore or get help
Reach the Gavel Exec team by email, phone, or scheduled call for immediate help.
See what Gavel Exec can do and learn how to get the most out of the add-in.
# Workspaces and Sharing: Collaborate with Your Team
Source: https://helpdocs.gavel.io/exec/workspaces-and-sharing
Add team members, attorneys, and clients to your workspace, then share Projects and Playbooks with full control over who can view or edit.
A workspace is the environment inside Gavel Exec where you add your team members, other attorneys, and clients. All items in your workspace are private to you by default — nothing is visible to others until you explicitly share it. You can share [Projects](/exec/projects) and [Playbooks](/exec/playbooks) with anyone in your workspace, and you control exactly what level of access each person or group receives.
Workspaces make it easy to collaborate with clients directly inside Gavel Exec. Share a project or playbook with a corporate legal team or business partner as a read-only resource, so they stay informed without being able to alter your work.
## What you can share
You can share two types of items from your workspace:
* **Projects** — Deal-level contexts with uploaded files and standing instructions. See [Projects](/exec/projects) for details.
* **Playbooks** — Saved rule sets for consistent contract review. See [Playbooks](/exec/playbooks) for details.
## Two ways to share
### With everyone in the workspace
When you share with **Everyone in the Workspace**, all current and future workspace members receive access automatically. Use this approach for:
* Standardized playbooks that should apply consistently across your group
* Team-wide projects where all members need visibility
### With specific individuals
When you share with **Specific Individuals**, you select exactly who receives access. Use this approach for:
* Practice-area-specific playbooks that only some attorneys need
* Projects shared with external clients, such as corporate legal teams or business partners
## Permissions: Read-Only vs. Edit Access
When you share a Project or Playbook, you choose one of two permission levels:
The recipient can view and use the Project or Playbook but cannot make any changes to it.
**Best for:**
* Sharing standardized playbooks with junior associates or clients
* Distributing finalized projects as reference material
* Giving clients visibility into deal context without risk of edits
The recipient can make changes to the Project or Playbook and can add other people to it.
**Best for:**
* Collaborating with colleagues to develop a new playbook
* Iterating on a shared project with another attorney
* Co-managing a deal workspace with a partner or associate
Edit Access allows the recipient to add additional people to the shared item. Use it intentionally when you want to delegate sharing responsibilities.
# Gavel API Documentation
Source: https://helpdocs.gavel.io/workflows/api
Use the Gavel API to create workflow sessions with pre-filled data, retrieve generated documents, and list workflow metadata programmatically.
The Gavel API lets you integrate Gavel document automation into your own applications and systems. You can pre-populate workflow sessions with client data, retrieve the documents Gavel generates, and inspect the variable schema for any workflow — all without a user ever opening the questionnaire manually. The API is available to customers on **Scale plans**.
You need a Gavel API key to authenticate every request. See [Creating an API key](#creating-an-api-key) below.
## Authentication
All API endpoints authenticate via the `X-Api-Key` request header. Pass your Gavel API key as the value of this header on every request.
```http theme={null}
X-Api-Key: YOUR_GAVEL_API_KEY
```
Your base URL is your Gavel subdomain: `https://yourdomain.gavel.io`.
***
## Creating an API key
Sign in to your Gavel account with a Builder or Admin seat.
In the left sidebar, click **Settings**, then select **API Keys**.
Enter a name for the key (for your reference only), click **Create a Key**, and immediately copy the value shown.
Gavel does not let you retrieve an API key after you leave the page. Store the key somewhere secure — such as a password manager or secrets manager — before navigating away.
Paste the key into the `X-Api-Key` header of your API requests, or use it to connect the Word add-in or Zapier integration.
***
## Endpoints
### 1. Create a workflow session with pre-filled data
Use this endpoint to create a new session for a workflow and populate it with data from your system. When all variables are provided, the returned `continuation_url` takes the user directly to the document download page. When some variables are missing, Gavel prompts the user only for the missing answers before generating documents.
The URL-encoded, case-sensitive name of the workflow. For example, `My%20Gavel%20Workflow`.
```http theme={null}
POST /api/documate/v1/interviews/{interview_name}/new
Host: yourdomain.gavel.io
X-Api-Key: YOUR_GAVEL_API_KEY
Content-Type: application/json
```
#### Request body
The body contains a single `variables` object. Keys are variable names; values are the data to pre-fill.
* **Text / Number**: Pass a plain string or number.
* **Date**: Use the format `"2024-05-30T"` (ISO 8601 date with a trailing `T`).
* **Date Time**: Use full ISO 8601 format, e.g. `"2021-05-01T23:02:02.098Z"`.
* **Multi Select**: Pass an array of strings matching the exact option labels in your question. Strings that do not match an option are ignored.
* **Repeating Items**: Pass an array of objects, one per row. Each object's keys are the attribute variable names for that repeating item. Optional repeating items with no rows can be set to `[]`.
* **Nested Repeating Items**: Gavel supports one level of nesting. Add the nested repeating item as a key inside each parent repeating item object, using the same array-of-objects format.
* **`hsl_review_answers`**: Set to `true` to skip the final "Please review your answers" page. Gavel recommends using the **Skip the final review page** workflow setting instead whenever possible.
* **Invisible Logic variables**: You can post data into Invisible Logic variables by referencing them in single curly brackets inside your workflow, e.g. `{clientnumber}`.
#### Example request
The example below shows a workflow named **My Gavel Workflow** with every supported variable type.
```json theme={null}
{
"variables": {
"my_date_variable": "2021-05-01T",
"my_datetime_variable": "2021-05-01T23:02:02.098Z",
"firstname": "John",
"lastname": "Doe",
"age": 35,
"hsl_review_answers": true,
"my_repeating_item": [
{
"repeating_name": "Item 1",
"repeating_age": 1,
"my_nested_repeating_item": [
{
"nested_repeating_name": "Item 1's Nested Item 1",
"nested_repeating_age": 10
},
{
"nested_repeating_name": "Item 1's Nested Item 2",
"nested_repeating_age": 20
}
]
},
{
"repeating_name": "Item 2",
"repeating_age": 2,
"my_nested_repeating_item": [
{
"nested_repeating_name": "Item 2's Nested Item 1",
"nested_repeating_age": 30
},
{
"nested_repeating_name": "Item 2's Nested Item 2",
"nested_repeating_age": 40
}
]
}
],
"my_multi": [
"name of option",
"name of other option"
]
}
}
```
#### Example response
```json theme={null}
{
"continuation_url": "https://yourdomain.gavel.io/run/playground6/My%20Gavel%20Workflow/?session=TerMtx6W3o4xhhEq76MqaKL5t2FQcJ2a",
"session_id": "TerMtx6W3o4xhhEq76MqaKL5t2FQcJ2a"
}
```
A URL you can redirect the user to. If all variables were supplied, this lands on the document download page. If variables are missing, the user is prompted to fill in only the missing answers.
The unique identifier for the session. Use this to retrieve documents after the session is complete.
***
### 2. Retrieve document metadata from a session
After a workflow session is complete, use this endpoint to get metadata — name, format, type, and download URL — for every document associated with the session.
The URL-encoded, case-sensitive name of the workflow.
The session ID returned by the Create Workflow Session endpoint.
```http theme={null}
GET /api/documate/v1/data-manager/workflows/{workflow_name}/session/{session_id}/documents
Host: yourdomain.gavel.io
X-Api-Key: YOUR_GAVEL_API_KEY
```
#### Example response
```json theme={null}
{
"documents": [
{
"format": "docx",
"name": "output.docx",
"template": "sample_output.docx",
"type": "outputDocument",
"url": "https://yourdomain.gavel.io/api/documate/v1/data-manager/workflows/4/session/AD7xBNhgMZUK3QtxfwwjyM9OuhWHs7Tn/download-document?file_number=59&filename=output.docx&extension=docx"
},
{
"format": "pdf",
"name": "output.pdf",
"template": "sample_output.pdf",
"type": "outputDocument",
"url": "https://yourdomain.gavel.io/api/documate/v1/data-manager/workflows/4/session/AD7xBNhgMZUK3QtxfwwjyM9OuhWHs7Tn/download-document?file_number=60&filename=output.pdf&extension=pdf"
},
{
"format": "pdf",
"name": "user_upload.pdf",
"template": "uploadedFile[0]",
"type": "fileUpload",
"url": "https://yourdomain.gavel.io/api/documate/v1/data-manager/workflows/4/session/AD7xBNhgMZUK3QtxfwwjyM9OuhWHs7Tn/download-document?file_number=58&filename=user_upload.pdf&extension=pdf"
}
]
}
```
An array of document objects for the session.
File format: `docx` or `pdf`.
The output file name.
The source template file name, or `uploadedFile[n]` for user-uploaded files.
Either `outputDocument` (a generated document) or `fileUpload` (a file the user attached during the workflow).
The URL to download this document binary. Pass this to the Download Document endpoint.
***
### 3. Download a document
Download the binary contents of a generated or uploaded document. In practice, you should use the `url` field returned by the Retrieve Document Metadata endpoint rather than constructing this URL manually.
The internal workflow ID (appears in the metadata response URL).
The session ID associated with the document.
An internal number associated with the specific document.
The file name of the document.
The file extension (e.g. `docx`, `pdf`).
```http theme={null}
GET /data-manager/workflows/{workflow_id}/session/{session_id}/download-document?file_number={file_number}&filename={filename}&extension={extension}
Host: yourdomain.gavel.io
X-Api-Key: YOUR_GAVEL_API_KEY
```
**Response:** The raw binary file contents of the document.
Construct this request by copying the `url` from the documents metadata response. You do not need to assemble the query parameters by hand.
***
### 4. List workflow names
Returns an array of all workflow names available on your account. Use these names to construct paths for the other endpoints.
```http theme={null}
GET /api/playground?folder=questions
Host: yourdomain.gavel.io
X-Api-Key: YOUR_GAVEL_API_KEY
```
#### Example response
```json theme={null}
[
"Continued.yml",
"Divorce Workflow.yml",
"Evictions.yml",
"Express Workflow.yml"
]
```
The names returned include the `.yml` extension. Use the full string (e.g. `Divorce Workflow.yml`) as the `pgtypes` parameter in the List Workflow Variables endpoint.
***
### 5. List workflow variables
Returns the variable schema for a specific workflow — including each variable's name, data type, input type, label, and whether it is required. Use this to understand what data to pass when creating a session.
The workflow name as returned by the List Workflow Names endpoint, including the `.yml` extension. Example: `Divorce Workflow.yml`.
```http theme={null}
GET /officeaddin?pgtypes={workflow_name}.yml
Host: yourdomain.gavel.io
X-Api-Key: YOUR_GAVEL_API_KEY
```
#### Example response
```json theme={null}
{
"attachments": [],
"success": true,
"types_json": {
"types_list": [
{
"datatype": "text",
"inputtype": "radio",
"label": "Marital Status",
"required": true,
"selections": ["Married", "Single"],
"variable": "marital_status"
},
{
"datatype": "text",
"label": "My Text 2",
"required": true,
"variable": "my_text2"
}
]
}
}
```
This endpoint also powers the Gavel Word add-in. The response may include additional metadata for button and instruction block elements used in the add-in, which you can safely ignore when building integrations.
# Bundles: Group Workflows
Source: https://helpdocs.gavel.io/workflows/bundles
Combine multiple workflows into one shareable bundle, set free or paid Stripe pricing, enforce completion order, and embed bundle cards on your site.
Bundles let you group multiple workflows together under one link or embeddable card. A client who accesses your bundle can move through each workflow in the package — for example, an estate planning bundle might include a will questionnaire, a healthcare proxy, and a power of attorney — rather than receiving three separate links. You can offer bundles for free or gate them behind a Stripe payment, and you can control whether users must complete the workflows in a specific order.
## Viewing and creating bundles
Select **Bundles** from the left-hand menu on your Dashboard to open the Bundles page. All existing bundles are listed here, and from here you can create, edit, duplicate, copy links, and manage assignments.
***
## Creating a free bundle
Click **+ New Bundle** on the Bundles page.
Enter a **Bundle Name** that describes the outcome for the user — for example, "LLC Formation," "Estate Planning — Wills and Trust," or "Pre-Marital Agreement Package." This name is displayed to your clients.
Click **Next** and enter a **Bundle Description** explaining what the user will receive or accomplish by completing this bundle. This is also visible to end users.
Choose the workflows you want to include. You can reorder them by clicking and dragging the handle (⠿) to the left of each workflow name. Delete any workflow from the bundle by clicking the trash icon.
If you want users to complete the workflows sequentially rather than in any order, check **Bundles must be completed in the order above**.
On the Bundle Pricing screen, choose **Free**.
Click **Finalize** (or **Save** and use the back arrow) to return to the Bundles page.
***
## Creating a paid bundle
To charge clients before they access a workflow or before documents are generated, you need a **Stripe Connect** account linked to Gavel.
Follow steps 1–5 from the free bundle instructions above to name, describe, and select your workflows.
On the Bundle Pricing screen, select **Flat Rate**. If you have not yet connected Stripe, a yellow banner will appear prompting you to complete the Stripe Connect onboarding. Click the link in the banner and follow the steps. You will be redirected back to Gavel once onboarding is complete.
If you previously used the legacy Stripe Paywall Questions feature, you had a standard Stripe account connected. For bundles, you connect a **Stripe Connect** account instead. The onboarding flow will guide you through linking them.
Enter the flat-rate amount users will be charged.
Select where in the bundle the payment step appears. You can require payment:
* Before the user begins any workflow in the bundle
* Before documents are generated for any specific workflow
Click **Add another payment step** if you want to collect payment at multiple points.
Click **Finalize** to save and return to the Bundles page.
To view payments, customers, and reports for your bundle purchases, sign in to your Stripe dashboard at [dashboard.stripe.com](https://dashboard.stripe.com) and use the toolbar to navigate to Products, Payments, or Reports.
***
## Sharing a bundle link
Once a bundle is saved, you can give clients access to it by sharing a direct link.
1. On the Bundles page, click the **copy** icon next to the bundle you want to share.
2. Paste the copied URL into an email, a chat message, or as the destination of a button on your website.
When a client opens the link, they see the bundle's start page — including the name, description, and pricing — before beginning the first workflow.
Admins and Builders can also click the **Run** button next to a bundle on the Bundles page to start the bundle themselves, which is useful for testing.
***
## Embedding a bundle card on your website
Rather than sharing a plain link, you can embed a visual bundle card directly into a web page. The card displays the bundle name, description, and a button for clients to get started.
On the Bundles page, click the **Generate Code** icon (``) for the bundle you want to embed.
The dialog provides two code snippets:
* A **Head snippet** — paste this inside the `` tag of your page HTML.
* A **Body snippet** — paste this inside the `` tag where you want the card to appear.
Add both snippets to your page. A preview of the bundle card will appear once the code is in place.
In the Squarespace editor, click **Edit**, then **+ ADD BLOCK** and choose either **Embed** or **Code**. Click the new block, then the pencil icon, and paste the Head snippet in the `` and the Body snippet in the ``. A live preview of your card should appear in the editor.
WordPress requires a Business Plan subscription to run custom JavaScript. The simplest approach is to use a JavaScript WordPress plugin. Once the plugin is active, add the Head snippet to your site's `` and the Body snippet to the page content where the card should appear.
***
## Assigning bundles to users
You can push a bundle directly into a user's portal so it appears there automatically, rather than requiring them to follow a shared link. There are three assignment methods:
On the Bundles page, click the purple **Assign** button for the bundle. Check the box **Automatically assign this bundle to all current and future users**. The bundle will immediately appear in the portal of every existing user on your account — Admin, Builder, Organizational User, and User — and will be automatically assigned to every new user who joins.
Users can view all their assigned bundles by going to `yoursubdomain.gavel.io/portal`.
Click the purple **Assign** button, then type an email domain (e.g., `clientfirm.com`) into the domain field and add it. Every user whose account uses that email domain will have the bundle assigned to their portal automatically — including future users who sign up with that domain.
Click the purple **Assign** button, then type a user's email address or select it from the dropdown. After assigning, the user's address appears in the list of assignees. Repeat for each individual user you want to add.
### Removing an assignment
To unassign a bundle from a specific user or domain, click the purple **trash can** icon to the right of their name or domain in the assignment list. Once removed, the bundle no longer appears in that user's portal.
***
## Duplicating a bundle
To create a copy of an existing bundle — useful when building a variant with different pricing or a slightly different workflow set — click the **duplicate** icon on the far right of the bundle row on the Bundles page. The duplicate is created immediately and can be renamed and reconfigured independently.
# Calculations: Advanced Logic
Source: https://helpdocs.gavel.io/workflows/calculations
Create computed variables, set conditional values, automate pronoun handling, and perform numerical and date calculations in your Gavel workflows.
Calculations — previously called Invisible Logic — let you create new variables whose values Gavel computes automatically, without asking the client another question. You define a formula or a set of conditional rules, and Gavel evaluates them behind the scenes to produce a value that you can use anywhere in your document templates or question logic. This is the tool to reach for whenever you need to derive information from what the client already told you, rather than asking for it directly.
You access Calculations from the **Calculations** page at the top of the screen when editing a workflow.
***
## Why use Calculations?
Gavel can perform arithmetic on numeric answers so you don't have to ask for derived values. For example, divide an annual salary by 12 to produce a monthly figure, then reference that computed variable in your document.
Merge separate fields — such as first name, middle name, and last name — into a single full-name variable. You collect the parts once and reference the assembled whole wherever you need it, without asking the client for their full name again.
Set a variable to different text values depending on conditions. The classic use case for legal documents is pronouns: assign "He," "His," and "Testator" or "She," "Her," and "Testatrix" based on the client's stated gender.
Calculate deadline dates, ages, or eligibility dates automatically. For example, compute whether a client's birthday means they were under 18 as of today, and use that result to control what pages they see.
***
## Creating a Calculation variable
While editing your workflow, click the **Calculations** tab at the top of the screen.
Add a new Calculation variable and give it a name. Choose the variable type (Text, Number, Date, etc.) to match the kind of value you want to produce.
In the formula field, enter the value the variable should have when no specific condition is met. For a conditional variable, this is typically an empty string `" "`. For a straightforward formula with no conditions, enter the expression directly here.
To insert values in the formula field, click inside it to see a dropdown menu:
* Click **Enter text** to type a text literal (Gavel adds the quotation marks)
* Click **Enter space** to insert a blank space `" "`
* Click a variable name (prefixed with `@`) to reference any existing variable
* Scroll down to find functions such as add, concatenate, or format date
Click **Add Logic** to define conditions under which the variable should take a different value. Each condition specifies: *when \[variable] equals \[value], set this Calculation variable to \[output]*.
You can group multiple Calculation variables together and apply the same logical condition to all of them at once — useful when a single condition (such as gender) drives several related variables (pronoun, possessive, title).
Each Calculation variable requires a fallback value. If your logic panel appears blank when you return to edit it, check that you have set a fallback in the formula field. This is often just an empty string for text variables.
***
## Referencing Calculation variables in documents
You reference Calculation variables in your DOCX or PDF templates using the same double-curly-bracket syntax you use for any regular questionnaire variable:
```text theme={null}
{{ CalculationVariableName }}
```
Calculation variables work seamlessly across your entire workflow — in document templates, question logic conditions, and instruction blocks.
***
## Setting conditions for pronouns
Handling pronouns is one of the most common Calculations use cases in legal document automation. Instead of scattering conditional logic throughout your template, you create a small group of pronoun variables in Calculations and then reference those variables everywhere a pronoun appears.
Add a single-select question with a variable such as `ClientGender` and choices like Male, Female, and Non-binary.
In Calculations, create a group of new variables for the pronoun forms you need. For a will or trust, you might create:
* `ClientPronounSubject` (He / She / They)
* `ClientPronounPossessive` (His / Her / Their)
* `ClientTitle` (Testator / Testatrix / Testator)
Add logic to the group:
Set the fallback for each variable to an empty string.
Create a second Calculations group for spouse pronouns, following the same pattern with a `SpouseGender` question as the source.
Reference the pronoun variables anywhere in your document:
```text theme={null}
{{ ClientTitle }} hereby declares that {{ ClientPronounSubject }} is of sound mind
and wishes to dispose of {{ ClientPronounPossessive }} estate as follows.
```
***
## Numerical calculations
For numeric computations in your document templates, you can write mathematical expressions directly in your template using double curly brackets. Make sure the source questions use the **Number** or **Integer** question type.
```text theme={null}
{{ (variable1 + variable2)|float }}
```
Displays the sum of two variables as a decimal number.
```text theme={null}
{{ (100 * variable1 / variable2)|float }}
```
Useful for expressing a value as a percentage of another.
```text theme={null}
{{ (variable)|round(2, 'floor') }}
```
Rounds down and keeps two decimal places.
```text theme={null}
{{ (variable)|round(2, 'ceil') }}
```
Rounds up and keeps two decimal places.
```text theme={null}
{{ (variable1**variable2)|float }}
```
Raises `variable1` to the power of `variable2`.
When combining rounding with number formatting, place the rounding call *inside* the parentheses:
```text theme={null}
{{ "{:,.0f}".format(variablename|round(0,'ceil')) }}
```
***
## Date calculations
Gavel provides a full set of date-calculation functions you can use directly in document templates.
### Calculate age or time elapsed
```text theme={null}
{{ (date_difference(starting=DateVariable).years|int) }}
```
Outputs the number of whole years between a date variable and today. This is the standard pattern for calculating a client's age from their date of birth.
### Calculate between two specific dates
```text theme={null}
{{ (date_difference(starting=StartDate, ending=EndDate).years|int) }}
```
### Add or subtract days, months, or years
```text theme={null}
{{ format_date( (DateVariable) + date_interval(years=2) ) }}
```
Use `-` instead of `+` to subtract. You can substitute `years`, `months`, `days`, or `weeks` for the unit. This is especially useful for computing statute of limitations deadlines and notice periods.
### Add or subtract business days
```text theme={null}
{{ format_date( (DateVariable) + date_interval(bus_days=10) ) }}
```
### Calculate months between two dates
```text theme={null}
{{ (relative_date_difference(starting=StartDate, ending=EndDate).months) }}
```
### Find the next or prior business day
```text theme={null}
{{ next_business_day(DateVariable) }}
{{ prior_business_day(DateVariable) }}
```
### Date-based conditional eligibility
You can use Calculations to create eligibility date variables and then drive page logic from them. For example, an attorney who only represents minors can compute:
```text theme={null}
eligibility_date = today() - date_interval(years=18)
```
Then set a page condition of `client_birthday > eligibility_date` to show the minor-specific page only to qualifying clients.
### Display conditional messages based on dates (in questions)
In instruction blocks within your questionnaire, you can show different text based on a date comparison:
```text theme={null}
${ "We are sorry. You are too late." if date_difference(starting=FilingDate).days > 30 else "Great. Let's continue." }
${ "You made it before the deadline" if DateVariable > as_datetime("2025-12-31") else "You are past the deadline." }
```
# Cancelling Your Workflow Account
Source: https://helpdocs.gavel.io/workflows/cancel-account
How to cancel your Gavel Workflows account, what happens to your workflows and data after cancellation, and how to reach support if you need help.
We're sorry to see you go. If you'd like to cancel your Gavel subscription, follow the steps below.
**Important: Only the original creator of the Gavel account can deactivate it, even if someone else is the current Admin.**
## How to cancel
1. [**Click here.**](https://start.gavel.io/users/sign_in?_gl=1*1xu088p*_gcl_au*NzQ0NTM4MjA2LjE3NDEyODAyNjM.\&query=Cancel)
2. **Sign in with original account email/password**
3. **Can't sign in? Use password reset**
Cancellation must be submitted **before your next renewal date** to avoid being charged for the upcoming billing period.
## What happens after you cancel
* **Workflows and document templates** — Your workflows, templates, and generated documents will be deleted upon cancellation
* **Client data** — Any client responses collected through your workflows will also be removed when your account is closed.
* **Billing** — You won't be charged again after your cancellation is processed. Gavel does not provide prorated refunds for partial billing periods.
## Reactivating your account
If you change your mind, you can reactivate your account at any time by emailing [help@gavel.io](mailto:help@gavel.io). If your account data is still within our retention window, we can often restore your workflows and templates exactly as they were.
## Need help instead?
If you're cancelling because something isn't working the way you expected, we'd love the chance to help first.
Email, call, or book a 30-minute call with the Gavel Workflows team.
Tell us what's missing — the team reviews every feature request.
# Gavel Workflows Certification Courses
Source: https://helpdocs.gavel.io/workflows/certification-course
Become a certified Gavel Workflows user through our online courses on Gavel University — learn best practices, advanced features, and earn your certification.
## Get Certified in Gavel Workflows
Level up your skills with the **Gavel Workflows courses** on Gavel University. These self-paced courses walk you through everything you need to confidently build and share workflows — from the basics to automating complex engagement agreements.
Start here to learn the fundamentals of Gavel Workflows, from your first questionnaire to generating documents.
Follow a step-by-step course on automating an engagement agreement end-to-end in Gavel.
## What you'll learn
* How to build a questionnaire and connect it to a document template
* Best practices for tagging Word and PDF templates
* How to use conditional logic, calculations, and repeating items
* Tips for sharing workflows, building client portals, and bundling products
* Real-world use cases and example workflows from practicing attorneys
## Why get certified
* **Build confidence** using Gavel Workflows across your practice
* **Save time** by learning the fastest path to common tasks
* **Showcase your expertise** with an official certification from Gavel
The certification courses complement the [Video Series](/docs/gavel-101/workflow-video-series) and written documentation. Use them as a structured way to onboard yourself or your team.
Watch short tutorials covering Gavel Workflows' main features.
Have questions about the courses? Reach out to the Gavel team.
# Client Portals
Source: https://helpdocs.gavel.io/workflows/client-portals
Build public or login-gated portals, assign specific workflows to users, control access permissions, and configure multiple-signature workflows.
Gavel gives you two distinct ways to present workflows to people outside your builder team: a publicly accessible internal portal (a curated list of workflow links hosted on your Gavel subdomain) and a login-based client portal where each user sees only the workflows you've explicitly assigned to them. Understanding the difference helps you choose the right setup for each audience.
## Internal portals — a public page of workflows
An internal portal is a simple, publicly accessible page that displays a list of your workflows as clickable links. No login is required to reach this page. It is useful when you want colleagues or clients to browse and select from a set of workflows without creating an account.
You build an internal portal by creating a special workflow that contains only a **Kickout Page** formatted as a link menu.
From your Dashboard, click **New Workflow** and give it a name that reflects its purpose — for example, "Client Resources" or "Self-Service Documents."
Inside the workflow builder, add a **Kickout Page** question. This page will be the landing screen users see immediately — no questionnaire questions precede it.
In the body of the Kickout Page, add links to your other workflows using standard Markdown link syntax:
```text theme={null}
[Text you want to appear](workflow link URL)
```
You can add as many links as you like. You can also embed images, videos, or introductory paragraphs to give the page more context.
Click **Save and Run**. Gavel generates a URL for this page. Copy it from the Dashboard using the three-dot menu (**Copy workflow link**) and share it with your clients or embed it on your website.
If you want this portal page to be the default landing screen when someone visits `yoursubdomain.gavel.io`, email [help@gavel.io](mailto:help@gavel.io) and the team will configure it for you.
***
## Client portals — login-gated, personalized access
A client portal requires the user to sign in before seeing any workflows. Once logged in, each user sees only the specific workflows or bundles you've assigned to them. Their answers are saved to their account, so they can return and pick up where they left off.
### Requiring login on a workflow
Go to the **Settings** tab of a workflow, then click **Access Permissions**.
Change the setting from **Anyone with Link** to **Only Logged-In Users** and save. You can optionally further restrict access to:
* Specific email addresses only
* Any email address belonging to a specific domain (e.g., everyone at `@yourclientfirm.com`)
Enable **Allow each user to complete this workflow only once** if you want to prevent users from editing their session after generating documents or reaching the end of the workflow.
When a client clicks a login-required workflow link for the first time, they are taken to your Gavel sign-in page and prompted to create an account. Once they sign in, the workflow appears in their portal.
***
## Assigning workflows to specific users
Admin and Builder users can push specific workflows directly into a user's portal, rather than relying on the user to discover the link themselves. The assigned user receives an email notification and sees the workflow in the **My Workflows** section of their dashboard.
On the Dashboard, locate the workflow you want to assign.
Click the **three dots** (⋯) next to the workflow name and select **Share data entry only version**.
In the dialog that opens, choose the users from the dropdown and click **Assign Workflow**. The selected users are notified by email.
To remove a user's access, open the same **Assign Workflow** dialog and click the **×** next to the user's name.
Assigned workflows remain in the user's portal until you explicitly revoke access — they are not automatically removed after the user completes them.
***
## Access permissions reference
The table below summarizes how the access permission settings work:
| Setting | Who can access |
| ------------------------------ | --------------------------------------------------------------------- |
| **Anyone with Link** (default) | Any person who has the URL — no account required |
| **Only Logged-In Users** | Any person who creates a Gavel account and signs in |
| **Specific email addresses** | Only users whose exact email address is on the allow-list |
| **Specific email domain** | Any user whose email belongs to that domain (e.g., `@clientfirm.com`) |
If a workflow contains a Clio integration question or a CSV data source set to **private**, only users with Builder privileges can access it. If you see an "Unauthorized" message when sharing such a workflow, either set the CSV to public or grant Builder access to those users.
***
## Multiple signatures
When a generated document needs signature lines for multiple parties — such as all members of an LLC or all signatories to an agreement — you can automate this using a **Repeating Item** question.
### Setting up repeating signature lines
In your workflow, add a **Repeating Item** question for the signatories (e.g., item name: `Members`, attribute name: `MemberName`).
In your Word document template, insert the repeating variable inside a **table** using the Word add-in. Select the item as a repeating item and choose **Table** as the formatting. Adding a line immediately above the variable in the table creates a signature line above each name.
Make the table borders **clear (no borders)** so that the final document shows only the underline and the name — not a visible grid.
Run the workflow and enter one member, then run it again with several members. Each signatory will appear on their own row with their own signature line.
### Two signatories side by side
If you want signatures to appear in two columns (odd entries on the left, even entries on the right), Gavel supports a special two-column table syntax in the Word add-in. Use `ItemName` for the Repeating Item name and `ItemAttributeName` for the attribute name inside that item.
Setting up signature tables is easiest when the table borders are removed after you've confirmed the layout looks correct. Use Word's **No Border** table style to hide the grid.
# Clio Integration
Source: https://helpdocs.gavel.io/workflows/clio
Link your Clio Manage account to Gavel to pull contact and matter data into workflows, tag documents with Clio fields, and send output to Clio matters.
Gavel's Clio integration lets you run a document automation workflow with a single click by pulling client and matter data directly from Clio Manage. Instead of re-typing contact names, addresses, matter details, and custom field values, you select a matter and/or multiple contacts in the Gavel questionnaire, and Gavel fills in every tagged field automatically. You can also send the generated documents back to the Clio matter using Clio's maildrop address feature.
Workflows that contain Clio Contact or Clio Matter questions are only accessible by Builder users who are logged into your Gavel subdomain. End-users cannot access these workflows directly, which protects the sensitive data stored in Clio.
***
## Link your Clio account to Gavel
From your Gavel dashboard, click **Integrations** in the left navigation sidebar.
If your Clio account is hosted in Canada, the European Union, or Australia, choose the appropriate region from the dropdown. Leave the dropdown blank if you are on the default US servers.
Click the **Link Account** button in the Clio integration module.
You will be redirected to a Clio login page. Sign in to your Clio account and click **Allow Access**. You will then be returned to the Gavel integrations page.
Clio connections are global for your Gavel instance. Linking Clio from one Builder seat also links all other Builder seats on the same account. All new contacts, matters, and custom fields sync automatically.
***
## Add Clio Contact and Clio Matter questions
Once your accounts are linked, you can add Clio data to any workflow by inserting a **Clio Matter** and/or multiple **Clio Contact** question types. You will only select one matter to connect but you can have multiple contacts added to the workflow.
When a user runs the workflow, the Clio question appears as a searchable list of all contact or matter records from Clio. The user selects the relevant record, and Gavel automatically maps all of its fields to your document template.
***
## Tag your documents with Clio field syntax
Clio fields appear in the [Word Gavel Document Tagger](https://helpdocs.gavel.io/workflows/word-documents#install-the-gavel-word-add-in) and use the following syntax structure:
```text theme={null}
GavelVariableName['ClioFieldSet'].ClioFieldName
```
For example, if you created a Clio Contact question with the variable name `ClioContact`, a contact's first name would be referenced as:
```text theme={null}
ClioContact['client'].firstname
```
### Common Clio field sets
| Field set | Description |
| --------------- | ----------------------------------------------------- |
| `client` | Standard contact fields (name, address, phone, email) |
| `date` | Date fields on the contact or matter |
| `custom_fields` | Any custom fields you have configured in Clio |
### Using Clio variables in document templates
Insert Clio variable syntax using double curly braces in your document template:
```text theme={null}
{{ ClioContact['client'].firstname }} {{ ClioContact['client'].lastname }}
```
***
## Advanced Clio variable syntax
Clio passes all data to Gavel as text strings, not typed values. Use the following syntax patterns to perform calculations, format dates, and add conditional logic.
You can also use this syntax for [CSV questions!](https://helpdocs.gavel.io/workflows/question-types#integration-questions)
Wrap the Clio field in the `currency()` function:
```text theme={null}
{{ currency(ClioContact["client"].salary) }}
```
Clio numeric fields arrive as strings. Cast them to integers with `|int` before performing math:
```text theme={null}
{{ (ClioContact["client"].salary|int) / 40 }}
```
This example divides the salary field by 40.
Clio date fields arrive as text strings. Use `as_datetime()` and `strftime()` to format them:
```text theme={null}
{{ as_datetime(ClioContact["date"].open_date).strftime("%B %d, %Y") }}
```
To write the date as "the 5th day of March, 2025":
```text theme={null}
the {{ ordinal_number(as_datetime(ClioContact["date"].open_date).strftime("%d"), use_word=False) }}{{ as_datetime(ClioContact["date"].open_date).strftime(" day of %B, %Y") }}
```
Use standard Gavel `if` logic with Clio field references:
```text theme={null}
{% if ClioContact["custom_fields"].maritalstatus == "Married" %}The client is married.{% endif %}
```
```text theme={null}
{% if ClioContact["client"].firstname %}Conditional text if the field is not blank.{% endif %}
```
To see all available Clio fields and variable names for your account, create a short "mini workflow" in Gavel with a single Clio Contact or Clio Matter question and preview it. The Word add-in will show you the complete list of field paths available.
***
##
# Template: Show Paragraph and Phrases
Source: https://helpdocs.gavel.io/workflows/conditional-content
Show or hide inline phrases, full paragraphs, numbered clauses, and table rows based on client answers using Gavel's conditional content syntax.
Conditional content lets you build a single document template that produces different output depending on how each client answers your questionnaire. Instead of maintaining separate templates for every scenario, you mark sections of your Word document with simple logic tags — Gavel evaluates those tags at document-generation time and includes or omits the content accordingly. You can apply this logic to anything from a single word to an entire page of clauses.
## Conditional phrases and sentences
A conditional phrase is any inline text — a word, a clause, or a full sentence — that you want to appear only when a certain condition is true. The tags wrap tightly around the text and sit inside the surrounding permanent paragraph.
### Basic syntax
```text theme={null}
{% if VariableName %}Conditional text here.{% endif %}
```
The condition evaluates as true when the variable has a value (for Yes/No questions, this means "Yes").
### Syntax by question type
Show text when the answer is **Yes**:
```text theme={null}
{% if HasSpouse %}including the Spouse's community property interest{% endif %}
```
Show text when the answer is **No** (i.e., False):
```text theme={null}
{% if HasSpouse == False %}as sole and separate property{% endif %}
```
Match a specific choice using `==`:
```text theme={null}
{% if MaritalStatus == "married" %}and spouse{% endif %}
```
Match anything *other* than a value using `!=`:
```text theme={null}
{% if EntityType != "LLC" %}as a corporation{% endif %}
```
Use `.all_false()` to show text only when none of the checkboxes are selected:
```text theme={null}
{% if Jurisdictions.all_false() %}No jurisdictions selected.{% endif %}
```
Show a placeholder when a field is left empty:
```text theme={null}
{% if MiddleName == "" %}N/A{% endif %}
```
Conditions work the same way for variables populated from a CSV data source:
```text theme={null}
{% if CSV_Variable["CSV_Column"] == "Jane Doe" %}Attorney of record{% endif %}
```
### Multi-condition logic
Combine conditions with `and` or `or` to create more precise rules:
```text theme={null}
{% if MaritalStatus == "Married" and FavoriteColor == "Pink" %}
I am married and my favorite color is pink!
{% endif %}
```
### Using `else` and `elif`
Instead of writing separate `if`/`endif` blocks for every alternative, you can chain conditions using `else` (for one alternative) or `elif` (for multiple alternatives).
**Two options with `else`:**
```text theme={null}
{% if EntityType == "LLC" %}limited liability company{% else %}corporation{% endif %}
```
**Three or more options with `elif`:**
```text theme={null}
{% if MaritalStatus == "single" %}unmarried
{% elif MaritalStatus == "married" %}married
{% elif MaritalStatus == "divorced" %}formerly married
{% endif %}
```
The Word add-in inserts `else` and `elif` blocks for you through its UI. You only need to type this syntax manually if you are editing the document template directly in Word.
***
## Conditional paragraphs
When the content you want to show or hide is an entire stand-alone paragraph — not inline text within a permanent paragraph — you must use the `{%p ... %}` variant. The `p` flag tells Gavel to remove the paragraph's surrounding whitespace as well, so no blank lines are left behind in the final document.
### Basic syntax
```text theme={null}
{%p if VariableName %}
Conditional paragraph text here.
{%p endif %}
```
If you use `{% if %}` instead of `{%p if %}` around a standalone paragraph, the blank line that held the tag will remain in the output. Always use `{%p %}` for full-paragraph conditions.
### Conditional numbered paragraphs and table rows
The same `{%p %}` syntax works for numbered lists and table rows. Place the opening tag on its own line immediately before the item, and the closing tag on its own line immediately after:
```text theme={null}
{%p if IncludeArbitrationClause %}
Arbitration. All disputes arising under this Agreement shall be resolved by binding arbitration.
{%p endif %}
```
For a numbered paragraph inside a list, the surrounding numbers automatically re-sequence — Gavel removes the entire item, not just its text.
***
## Using the Word add-in (no-code)
You do not need to type syntax manually. The Gavel Word add-in lets you insert both phrase-level and paragraph-level conditions through a point-and-click interface.
Open your document in Microsoft Word and launch the Gavel add-in. Select the workflow you want to use.
Select the word, sentence, or paragraph you want to make conditional.
* For inline text within a paragraph, click **Show phrase when...**
* For a full standalone paragraph, click **Show paragraph when...**
Choose the variable name and the answer value that should trigger the content to appear.
Click **Add Condition** and repeat the previous step to build `and`/`or` multi-condition logic.
Click **Insert**. The add-in writes the correct syntax — including `{%p %}` for paragraph conditions — directly into your document.
The Word add-in is the recommended way to add conditions. It handles spacing, bracket style, and paragraph vs. phrase mode automatically.
***
## Full example
The following illustrates how phrase-level and paragraph-level conditions can work together in a single clause:
```text theme={null}
This Agreement is entered into by {%p if IsMarried %}the Parties, who are married to each other,{%p endif %}
{% if EntityType == "LLC" %}a limited liability company{% elif EntityType == "Corporation" %}a corporation{% endif %}
organized under the laws of the State of {{ State }}.
{%p if IncludeNDA %}
CONFIDENTIALITY. Each Party agrees to hold in strict confidence all information disclosed
by the other Party in connection with this Agreement.
{%p endif %}
```
In the generated document, the NDA paragraph either appears in full or is omitted entirely — with no blank line left in its place.
# Contact Gavel Workflows Support
Source: https://helpdocs.gavel.io/workflows/contact-us
Reach the Gavel Workflows team by email, phone, or scheduled call — get help with setup, billing, or any questions about building workflows.
The Gavel Workflows support team is available to help you with setup, billing, feature questions, and anything else you need. Choose the contact method that works best for you.
Send a message to [**help@gavel.io**](mailto:help@gavel.io) and the team will get back to you as soon as possible.
Reach us by phone at **(415) 941-6866** during business hours.
Schedule a 30-minute call with the Gavel Workflows team to walk through your questions or get hands-on help.
Have a feature idea or a suggestion for improving Gavel Workflows? Share it on the [Wishlist](/workflows/wishlist) page — the team reviews every submission.
[Need to Cancel your Gavel Workflows Account?](https://helpdocs.gavel.io/workflows/cancel-account)
# Data Manager
Source: https://helpdocs.gavel.io/workflows/data-manager
Use the Data Manager to view, filter, edit, and transfer workflow responses, download generated documents, and push client data between workflows.
The Data Manager is Gavel's central hub for every piece of data collected by your workflows. Every time a user starts or completes a workflow session, that session appears in the Data Manager alongside all of the answers entered, the documents generated, and the current session status. You can use the Data Manager to monitor activity across your account, correct answers and regenerate documents, move client data from one workflow to another, and download output files — all without asking your client to re-enter anything.
***
## What you can do with the Data Manager
See every session for any workflow, sorted and filtered by any variable value.
Open any session, change the answers, and regenerate revised documents instantly.
Transfer answers from one workflow directly into another, skipping questions that are already answered.
Download output documents from any completed session directly from the Data Manager.
***
## Viewing, sorting, and filtering workflow data
From your Master Dashboard, click the **Data Manager** tab. Then select **By Workflow**.
Choose the workflow you want to inspect from the first dropdown. You will see a list of all sessions, including those started by clients or colleagues who received a shared link.
Click any column heading to sort the session list by that value — for example, sort by date submitted or by a specific variable's value.
Click the **Filters** button to narrow the list by one or more criteria. For example, filter to show only sessions where a variable called `DiscloserEntityName` contains the word "Doe."
If you shared a workflow link with clients or colleagues, their sessions appear in the Data Manager and you can view, edit, or continue their responses on their behalf.
***
## Editing responses and regenerating documents
You do not need to start a workflow from scratch if a client's situation changes or if an answer needs to be corrected. Open the existing session, update the answers, and Gavel regenerates the documents with the revised data.
Navigate to **Data Manager > By Workflow** and select the relevant workflow.
Click **Open** next to the session you want to edit. This re-enters the workflow at the point where the session left off, with all previous answers pre-filled.
Change the answers you need to correct or update, then continue through the workflow to regenerate the output documents.
This is also how you support multi-user workflows: share the link with a client so they complete part of the questionnaire, then use Data Manager to open their session, review their answers, and complete any remaining questions before generating documents.
***
## Pushing data from one workflow to another
If you represent the same client through multiple phases — intake, drafting, court filings — you can build a separate Gavel workflow for each phase and use Data Manager to transfer the client's answers forward. Any variable that has the same name in both workflows is transferred automatically; you are only prompted to answer the questions that are new in the second workflow.
Go to **Data Manager > By Workflow** and select the workflow you want to pull data from.
Click the session whose data you want to transfer.
In the **Push into another workflow** dropdown, select the workflow you want to populate with this client's data.
Click the button to push the data. A new session opens in the target workflow with all matching variable values pre-filled. You are then prompted to answer any questions that exist in the target workflow but were not in the source.
For data transfer to work, the variable names must match exactly between the two workflows. For example, if Workflow 1 uses `clientname`, Workflow 2 must also use `clientname` — not `ClientName` or `client_name`. Variable names are case-sensitive.
***
## Setting up workflows for data reuse
The most efficient way to build a multi-phase workflow system is to duplicate your first workflow and add or remove questions for subsequent phases, rather than building each workflow from scratch.
Build Workflow 1 with all the questions and document templates needed for the first phase of your client engagement. Use consistent variable names throughout.
From the dashboard, click the duplicate icon next to Workflow 1. This creates an identical copy with all the same variable names intact.
Give the duplicate a new name that reflects the second phase (for example, "Transaction NDA and Joinder").
Add any new questions needed for Phase 2. Go to the **Document Templates** tab, remove the Phase 1 documents, and attach the Phase 2 documents. Tag those documents using the PDF tagger or Word add-in.
Run Workflow 2 standalone to verify it works correctly before testing the data push.
Complete a session in Workflow 1, then use **Data Manager > Push into another workflow** to transfer the data into Workflow 2.
***
## Deleting sessions
To permanently remove a session and its associated data, select the session in the Data Manager, open the **Bulk Actions** menu, and choose **Delete**.
Deleting a session is permanent and cannot be undone. The session data and all generated documents associated with it will be removed.
***
## Downloading generated documents
From any session in the Data Manager, you can download the output documents Gavel generated for that session. Open the session and look for the download options in the session detail view. This is equivalent to using the [API endpoint to retrieve document metadata](/workflows/api#2-retrieve-document-metadata-from-a-session) and then downloading the file — the Data Manager provides a point-and-click interface for the same operation.
# Document Titles
Source: https://helpdocs.gavel.io/workflows/document-naming
Use variable values in your generated document file names so each output is automatically named after the client, matter, or other questionnaire answer.
By default, each generated document is named after the template file it was produced from. The naming convention feature lets you include the value of any workflow variable in the document's title, so the finished file is automatically named after the client, matter, date, or any other answer collected in the questionnaire. You set this up in the **Document Templates** tab — no additional configuration is required.
## How to set a dynamic document name
In your workflow, navigate to the **Document Templates** tab. You will see the list of templates attached to this workflow.
Click on the name of the document you want to rename. An editable name field appears.
Type the name you want the generated file to have. To include a variable value, use the `${ }` syntax anywhere in the name field. You can mix plain text and variable expressions.
Click out of the field or press Enter to save. From now on, every document generated from this template will use the naming convention you defined.
## Naming syntax
Variable values are inserted into document names using a dollar sign and single curly brackets:
```text theme={null}
${ variable_name }
```
This is different from the double-curly-bracket syntax used inside Word document templates. In document names, always use `${ }` (one set of curly brackets with a dollar sign).
### Single variable example
To name each generated file after the client, where the variable is `clientname`:
```text theme={null}
${ clientname } - Engagement Letter
```
If the variable value is `Jane Doe`, the generated file will be named:
```text theme={null}
Jane Doe - Engagement Letter
```
### Multiple variables example
You can include more than one variable inside the same `${ }` expression by joining them with `+`. To include a last name and first name with a space between them:
```text theme={null}
${ lastname + ' ' + firstname } - Retainer Agreement
```
If `lastname` is `Smith` and `firstname` is `John`, the generated file will be named:
```text theme={null}
Smith John - Retainer Agreement
```
You can insert any string literal between variables using single quotes, including spaces, hyphens, commas, or any other separator character that makes sense for your naming scheme.
### More examples
| Naming convention | Example output |
| ------------------------------------------- | ------------------------------------------- |
| `${ clientname } - NDA` | `Acme Corp - NDA` |
| `${ lastname }, ${ firstname } - Will` | `Smith, John - Will` |
| `${ mattername } - ${ documenttype }` | `John and Jane Doe Trust - Trust Agreement` |
| `Contract - ${ clientname } - ${ today() }` | `Contract - Jane Doe - 2025-04-13` |
The `${ }` syntax in document names is evaluated at the time the workflow is run, so each document gets the actual value the user entered — not a placeholder. If a variable has no value (the question was left blank), that portion of the name will be empty.
Include a descriptive static portion in every document name alongside the variable values. This makes it easier to identify documents in the Data Manager and in email attachments, especially when multiple documents are generated from the same workflow.
# Document Output Settings
Source: https://helpdocs.gavel.io/workflows/document-settings
Control output file types, hide documents from end users, send them by email automatically, and apply conditional logic to document generation.
After you attach document templates to a workflow, you can configure how Gavel handles the generated output. These settings control the file format of the finished documents, who sees them and when, which documents generate under what conditions, and where they are delivered. You manage all of these options from the **Document Templates** tab of your workflow.
## Output file type
When your template is a `.docx` file, Gavel can generate the output as a Word file, a PDF, or both. By default, the PDF format is produced.
To change the file type:
1. Open your workflow and go to **Document Templates**.
2. Click on Details under the Document Name
3. Select your preferred output: **Word only**, **PDF only**, or **Both**.
This setting determines which file types appear on the final screen of your workflow when the documents are displayed to the user. File types included in automated emails are configured separately.
All PDF template files always generate PDF output — this option only applies to Word-based templates.
## Displaying documents to users
By default, Gavel shows all generated documents to the end user at the end of the questionnaire. You can change this behavior in several ways.
If you do not want the user who filled out the questionnaire to see the generated documents — for example, if you are generating documents for internal review only — you can suppress the document display screen.
1. Open your workflow and go to **Document Templates**.
2. Click on the side bar **Sharing.**
3. Check **Do not display finalized documents to workflow taker**.
4. Check **Send finalized documents to email address** and enter the email address where the documents should go.
5. Click **Save**.
You can still view completed documents in the **Data Manager** if you are on the Standard, Pro, or Scale tier.
You can use logic to control which documents generate and display based on questionnaire answers. This lets you attach multiple possible output documents to one workflow and generate only the ones relevant to each user's situation.
To set up conditional document generation:
1. Open your workflow and go to **Document Templates**.
2. Make sure all possible output documents are attached to the workflow. You can attach the same document to multiple workflows.
3. Select **Logic** on the left side of the Document Templates tab.
4. Set default documents that generate every time.
5. Add rules that determine when each additional document generates.
For example, you might have four documents that always generate, plus a Living Trust document that only generates when the user selects "Revocable Living Trust" in a multi-select question. **If no logic is set, all attached documents generate.**
## Sharing documents via email
You can configure Gavel to automatically send the finished documents to an email address each time the workflow is run. You can specify a fixed email address or use the value stored in an email variable from the questionnaire (so the documents go directly to the person who filled out the form).
A PDF copy of each document is included in the email by default. If your documents were generated from Word templates, you can also choose to include an editable `.docx` version.
Automated emails are sent from `no-reply@mail.docautomation.org` with the sender name **Gavel** by default. Scale customers can configure a custom sender using a Mailgun account — contact [help@gavel.io](mailto:help@gavel.io) with your Mailgun email, API key, and domain.
You can customise the subject line and body of automated emails from the workflow settings.
If documents are displayed to the end user at the end of the workflow, the generated documents page includes a section where the user can email themselves a copy. If the user is logged into a Gavel account, their email address populates the field automatically.
## Generate Multiple (per repeating item)
If your workflow has a repeating item and you want to produce a separate copy of a document for each instance of that item — for example, one document per party or one document per asset — you must mark the template as **Generate Multiple** in the Document Templates tab.
If a template uses the Generate Multiple syntax in the document body but is not marked as Generate Multiple in the Output Documents tab, the workflow will produce an error. Always make sure the setting and the template syntax are in sync.
To enable Generate Multiple:
1. Open your workflow and go to **Document Templates**.
2. Click on the document's name.
3. Enable the **Generate Multiple** option.
## Quick reference: settings per document
| Setting | Where to find it | What it controls |
| ---------------------- | --------------------------------------------- | ----------------------------------------------------------- |
| Output file type | Click the document name in Document Templates | Word, PDF, or both for Word-based templates |
| Hide from end user | Document Templates tab, checkbox | Whether the questionnaire taker sees the finished documents |
| Send to email | Document Templates tab, email field | Auto-sends documents to a specified address on completion |
| Conditional generation | Document Templates > Logic | Which documents generate based on questionnaire answers |
| Generate Multiple | Click the document name in Document Templates | One document generated per repeating item instance |
# DocuSign Integration
Source: https://helpdocs.gavel.io/workflows/docusign
Connect DocuSign to Gavel, tag templates with signature anchors, configure recipients, and send envelopes automatically when workflows complete.
Gavel's DocuSign integration lets you send the documents generated by any workflow directly to DocuSign for electronic signature — without leaving Gavel or manually uploading files. When a user completes a workflow, Gavel packages the output documents into a DocuSign envelope, assigns it to the recipients you configured, and dispatches it automatically. Recipients receive an email from DocuSign and can sign, initial, or approve the document according to the role you gave them.
The DocuSign integration is available to customers on **Pro** and **Scale** plans. You also need an active DocuSign account with envelopes available.
***
## Step 1: Connect your DocuSign account
Log in to a Builder or Admin account. In the left navigation sidebar, click **Integrations**.
Scroll to the DocuSign integration module and click **Link account**. You will be redirected to DocuSign's login page.
Enter your DocuSign email and password. After successful authentication, you will be returned to the Gavel integrations page.
If the button now reads **Unlink Account** and is displayed in red, the accounts are successfully connected. The connected account will send all envelopes created by your Gavel workflows.
If you plan to send envelopes on behalf of multiple team members, the recommended best practice is to create a dedicated DocuSign account used exclusively for Gavel-generated envelopes.
### Optional: Configure DocuSign Connect and HMAC key
You can send documents from Gavel to DocuSign without an HMAC key. However, an HMAC key is required if you want to:
* Receive updated documents back from DocuSign after signing is complete
* View envelope status inside Gavel
* Trigger Gavel webhooks that include the signed documents
* Send Gavel emails that include the signed documents
To obtain an HMAC key, you need **DocuSign Connect** enabled on your DocuSign account. Visit `https://admin.docusign.com/connect-signatures`, click **ADD SECRET KEY**, copy the key to your clipboard, and paste it into the HMAC key field in Gavel.
If you do not see an **ADD SECRET KEY** button on the DocuSign page, DocuSign Connect is not enabled on your account. Contact your DocuSign account representative to enable it.
***
## Step 2: Select which documents to send for signing
In your workflow's builder view, click the **Document Templates** tab.
Check the box labeled **Send documents for DocuSign Signature**. Additional DocuSign configuration options will appear.
You will see a list of all the document templates attached to this workflow. Check the checkbox next to each document you want to send to DocuSign for signing.
If your workflow includes a file upload question and you want the user's uploaded files to be attached to the DocuSign envelope, check the box under **DocuSign Settings** labeled for file upload attachments.
***
## Step 3: Add recipients and set signing order
Click the purple **Add Recipients** button in the DocuSign settings section.
In the first text field, type the recipient's name if it will always be the same person. Alternatively, select a workflow variable (such as `client_name`) so that the name is populated dynamically from the questionnaire.
In the second text field, type a static email address or select an Email question variable from your workflow to use the email the client entered.
In the third text field, choose the role for this recipient. Click **View DocuSign Definitions** if you need to review what each role (Signer, Approver, In Person Signer, etc.) means in DocuSign.
Repeat the above steps for each additional person who needs to sign, approve, or receive the document. DocuSign will present the document to recipients in the order you add them.
***
## Step 4: Tag your document templates with DocuSign anchors
After setting up the output documents tab, you need to place signature, date, and initials anchors in the correct locations within each Word document template. Gavel uses the Word add-in to insert these anchors.
Open your Word document template and open the Gavel Word add-in panel.
At the bottom of the Word add-in, find the **Signatures** section and expand it. This section is enabled once you have set up the DocuSign integration for the workflow.
Use the dropdowns to choose:
* **DocuSign field** as the field type
* The **recipient** this anchor belongs to
* The **field action** — Signature, Date, Initials, or Approval
Click **Insert** to place the anchor at your cursor's current position in the document. Position it exactly where you want the recipient to sign or initial.
Save the document and upload it to your Gavel workflow using the normal document update process.
When the Word add-in inserts a DocuSign anchor, the outer brackets are rendered in white, making the anchor invisible in the printed output. DocuSign reads these anchors to position the signature fields. If you accidentally change the anchor text color, the anchor will appear as visible text in the DocuSign PDF.
Make sure your DocuSign account has envelopes available before you run a test workflow. If your envelope balance is empty, sending the document to DocuSign will trigger an error.
***
## Testing and going live
Once your templates are tagged and your recipients are configured, run the workflow from start to finish. After the questionnaire is completed, Gavel sends the documents to DocuSign automatically. Each recipient will receive an email from DocuSign where they can complete their assigned action.
To unlink your DocuSign account at any time, return to **Integrations** in Gavel and click the red **Unlink Account** button. The button will turn grey and revert to **Link Account** once disconnected.
# Estate Planning Builder Guide
Source: https://helpdocs.gavel.io/workflows/estate-planning-builder-guide
Explore the full range of use cases for Gavel document automation: internal drafting, client intake, client portals, expert systems, and paid workflows.
Gavel provides the tools to create workflows, or questionnaires, that gather data you can use to automate documents and so much more! There are many ways to set up a workflow. You can set up workflows that are internal only, client-facing, or a combination of both. From there, you can use [Data Manager](/workflows/data-manager) to push answers from one workflow to another workflow. This will eliminate the need to reenter information and reuse client data across many workflows.
Read on for tips on using Gavel to build your estate planning workflow and automate your documents.
## What Types of Documents Can I Automate?
Your first step in building an Estate Planning Workflow will be identifying the documents you want to automate. One workflow can produce one or many documents. By creating conditional logic on the output documents, you can decide which documents to produce based on the questions answered. For example, you could automate the following:
* Last Will & Testament
* Pour-Over Will
* Trust Funding Documents
* HIPAA Release
* Health Care Directive
* Health Care Power of Attorney
* Living Will
* Financial Power of Attorney
* Guardianship of Minors
* Guardianship of Pets
* Living Trust
* List of Important Documents and Beneficiary Designations
* Provision of Digital Assets
## How Should I Build My Workflow?
Before you begin building, you should consider how you plan to use the workflow.
* Do you want to create an internal system where your staff will use the workflow to output multiple documents? The **Multiple Documents Method** would be a good place to start.
* Do you envision a client-facing workflow where you guide your client through making decisions? Look at the **Intake or Interview Method.**
* Many estate planning attorneys have been using the **Important People Method.** This starts with a repeating item where the taker lists everyone they want to include in their estate plan. From there, they can select the person listed in the repeating item as beneficiaries, executors, guardians, etc.
Remember, these are just ideas, do what makes the most sense for your practice!
# The Multiple Documents Method
In this method, your starting point is the choice of documents.
![Multiple Docs Method]()
* Create a multi- or single-select question with different document output options.
* Use [page logic](/workflows/question-logic) and [conditional document logic](/workflows/document-settings) to make questions and documents appear based on the document choice question.
* For client-facing workflows, [use help text](https://helpdocs.gavel.io/workflows/question-types#question-settings) and [informational blocks](https://helpdocs.gavel.io/workflows/question-types#informational-blocks) to explain any confusing concepts and empower them to answer the questions.
* To turn your workflow into a legal product, [add a paywall with Stripe](/workflows/paywalls) after the document choice.
# The Intake or Interview Method
In this method, your starting point is the client’s information. The workflow then expands from there, like in an intake interview.
![Intake Method]()
* Lay out all of the information you need from the client.
* Determine which information depends on answers to other questions and which information you need to ask first.
* Ask the questions that others depend on first (e.g., First, ask questions like “What is your marital status?” or “Do you have children?”).
* Add [logic to questions](/workflows/question-logic) that are conditional (e.g., spouse name only appears if marital status is “married”) and [page logic](/workflows/question-logic) to any conditional pages (e.g., “children info” only appears if they have children).
* Use repeating items for children, beneficiaries, property, bank accounts, etc.
Your workflow could include repeating items for a variety of information you need to collect, as in this example for assets:
![Repeating Items]()
# The Important People Method
In this method, start by listing important people in a single repeating item variable, which you can then [reference in subsequent questions](https://helpdocs.gavel.io/workflows/repeating-items#reference-a-repeating-item-question). “Important people” could be family members or other individuals who will be named in the documents as beneficiaries or who will be given specific roles an the estate plan (e.g., guardian, executor, trustee). This is particularly good for more complex will and trust bundles, where people will be referenced in multiple roles throughout the documentation.
![Important People Method]()
* Start with a [repeating item](/workflows/repeating-items) that includes subquestions for name, contact information, relationship, and anything else about the “important people.”
* On a Client Information page, for the client name variable, create a single-select variable that [uses the repeat item names as its selection options](https://helpdocs.gavel.io/workflows/repeating-items#reference-a-repeating-item-question). You will use this method throughout to pull in the “important people.”
* For children information, use a [repeating item](/workflows/repeating-items). Create a single-select variable for “childname” that [pulls in the important people inputs as selection options](https://helpdocs.gavel.io/workflows/repeating-items#reference-a-repeating-item-question).
* Continue to create single-select variables that pull in the important people [repeat item inputs as selection options](https://helpdocs.gavel.io/workflows/repeating-items#reference-a-repeating-item-question) for the relevant roles in the estate plan (e.g., Trustee, Guardian, Executor)
* Add [logic to questions](/workflows/question-logic) that are conditional (e.g., spouse name only appears if marital status is “married”) and [page logic](/workflows/question-logic) to any conditional pages (e.g., “children info” only appears if they have children).
* **If you would like to see an example of this workflow design that you can also use to build off of, reach out to [help@gavel.io](mailto:help@gavel.io) and we can transfer that to your account.**
#### **Advanced**
* If you would like the user to be able to add to the list of “important people” whenever they’re asked to choose a person from one of the single-select variables you create, add `${ ItemName.add_action() }` to the question text. (Make sure to replace “ItemName” with your repeat item name.) This will insert an “Add Another” button that will take the user back to the earlier repeat item. Use [questionnaire formatting](/workflows/formatting-questions) to adjust the location of the “Add Another” button.
* Refer to [Reference a Repeating Item Question](https://helpdocs.gavel.io/workflows/repeating-items#reference-a-repeating-item-question) to set the syntax in your documents that will pull in the name and contact information of the important people in relevant parts of your document.
# File Uploads
Source: https://helpdocs.gavel.io/workflows/file-uploads
Add a File Upload question to collect supporting documents from respondents, and learn how to embed or reference uploaded files in your output documents.
The **File Upload** question type lets respondents attach a document or image directly within your Gavel questionnaire. This is useful any time you need supporting materials alongside the form data — a prior agreement, identification document, photo, or exhibit. You configure the question like any other in the Builder, and Gavel handles the upload and storage automatically.
Each File Upload question allows the respondent to upload **one file at a time**. If your workflow needs multiple separate files, add multiple File Upload questions — one per file.
***
## Accepted file types
File Upload questions accept the following file formats:
| Type | Extensions |
| --------- | -------------------------------------------------- |
| Documents | `.pdf`, `.docx`, `.doc`, `.txt`, `.rtf` |
| Images | `.png`, `.jpg` / `.jpeg`, `.tiff`, `.gif`, `.heic` |
Respondents can only upload one file per File Upload question. If you need multiple files, add multiple File Upload questions to your workflow.
***
## Adding a File Upload question
To add a File Upload question to your workflow:
1. In the Builder, click **+ Question** or **+ New → Question**.
2. Select **File Upload** from the question type list.
3. Write the question label that will prompt the respondent (for example, "Please upload a copy of your current lease agreement.").
4. Note the **variable name** Gavel assigns to the question — you will use this to reference the uploaded file in your output documents.
Use the **Settings** tab on the question to add informational text (an info bubble) that tells respondents exactly what file format and content you expect. This reduces confusion and re-submissions.
***
## Referencing uploaded files in output documents
How you handle an uploaded file in your output document depends on the expected file size.
### Embed the file inline (small files)
For small files — such as a signature image, a single-page exhibit, or a compact PDF — you can embed the uploaded file directly into your output Word document. Insert the variable tag wherever you want the file to appear:
```text theme={null}
{{ FileUploadVariable }}
```
Gavel copies the uploaded file directly into the generated document at that location.
### Control the display size
To limit how large the embedded file appears in the document, specify a width:
```text theme={null}
{{ FileUploadVariable.show(width="1in") }}
```
Replace `"1in"` with any valid measurement. This is particularly useful for images where you want a consistent display size regardless of the original file dimensions.
### Display only the file name
If you want to reference the file in your document without embedding it — for example, to list the name of an attached exhibit — use:
```text theme={null}
{{ my_file[0].filename }}
```
Replace `my_file` with your File Upload question's variable name.
### Large files: use email delivery instead
If you expect respondents to upload large files (multi-page PDFs, high-resolution images), do **not** embed the variable in your output document. Large embedded files can cause performance issues. Instead, configure the workflow to email the uploaded file to you when the questionnaire is submitted.
You can set this up in the **Document Settings** of your workflow by enabling the email delivery option for file uploads.
Embedding large files using `{{ FileUploadVariable }}` can significantly slow down document generation. For anything beyond a single page or small image, use the email delivery approach instead.
***
## Common use cases
Ask clients to upload a government-issued ID as part of a client intake workflow. Reference the filename in your intake summary document.
Collect an existing lease, contract, or deed to accompany a drafting workflow. Store the upload alongside the generated output for your records.
Accept property photos, inspection images, or signatures captured as image files. Embed small images directly into the generated document using the size-controlled syntax.
Accept a supporting PDF that will be attached alongside the generated document. Display the filename in the main document body for reference.
***
## Tips
* **Label clearly:** Write a specific, unambiguous question label. "Upload a file" is too vague. "Upload a signed copy of your current lease (PDF or Word)" is much better.
* **Set expectations in the info bubble:** Use the question's info bubble to tell respondents what file types are accepted and approximately what size is appropriate.
* **One upload per question:** If you need several distinct files (front of ID, back of ID, supporting letter), add a separate File Upload question for each one.
* **Test the upload:** Run through your workflow in Preview mode and upload a real file to confirm that the variable renders correctly in your output document.
# Formatting Dates, Numbers, and Text
Source: https://helpdocs.gavel.io/workflows/formatting
Apply date display formats, currency and number formatting, case transforms, and special number patterns like SSNs to variables in document templates.
```text theme={null}
The {{ ordinal_number(DateVariable.day, use_word=False) }} day of {{ format_date(DateVariable, format='MMMM yyyy') }}
```
Output: *The 15th day of January 2025*
### Converting text to a date
If you are importing data from another system (such as Clio) where the date field arrives as plain text rather than a date type, use `as_datetime()` with `strftime` to convert it:
```text theme={null}
{{ as_datetime(variable).strftime("%B %d, %Y") }}
```
Use `%-d` instead of `%d` to suppress the leading zero (e.g., "January 3" instead of "January 03").
### Formatting dates using Calculations (Invisible Logic)
You can also format a date variable through [Calculations](https://helpdocs.gavel.io/workflows/calculations#date-calculations). Create a new Text variable, select your date variable as the source, choose **Format Date** as the operation, and enter the format code. The resulting text variable can then be referenced anywhere in your document with `{{ FormattedDateVariable }}`.
***
## Calculating dates
These functions derive new date values from existing ones — useful for deadlines, notice periods, and age calculations.
```text theme={null}
{{ (date_difference(starting=DateVariable).years|int) }}
```
```text theme={null}
{{ (date_difference(starting=StartDate, ending=EndDate).years|int) }}
```
```text theme={null}
{{ (relative_date_difference(starting=StartDate, ending=EndDate).months) }}
```
```text theme={null}
{{ format_date( (DateVariable) + date_interval(years=2) ) }}
```
Replace `years` with `months`, `days`, or `weeks`. Use `-` instead of `+` to go back in time.
```text theme={null}
{{ format_date( (DateVariable) + date_interval(bus_days=10) ) }}
```
```text theme={null}
{{ next_business_day(DateVariable) }}
{{ prior_business_day(DateVariable) }}
```
```text theme={null}
{{ last_day_of_month(DateVariable) }}
```
To extract just the day number (e.g., 30):
```text theme={null}
{{ format_date(last_day_of_month(DateVariable), format='dd') }}
```
***
## Formatting numbers
Use a **Number** question type for decimal values and an **Integer** question type for whole numbers. Apply the functions below in your document template.
If you use a Number question type, decimal points display by default. If you use an Integer question type, you get a whole number.
### Standard number formats
```text theme={null}
{{ currency(variablename) }}
```
```text theme={null}
{{ Decimals0NoCommas(variablename) }}
```
```text theme={null}
{{ Decimals2Commas(variablename) }}
```
```text theme={null}
{{ Decimals0Commas(variablename) }}
```
```text theme={null}
{{ format_decimal(variablename, 2) }}
```
Replace the `2` with the number of decimal places you want.
```text theme={null}
{{ format_decimal(variablename, 2, False) }}
```
Replace the `2` with the number of decimal places you want.
### Ordinal numbers
Write a number as an ordinal (1st, 2nd, 10th, etc.):
```text theme={null}
{{ ordinal_number(variablename) }}
```
By default, first through ninth are written out as words (first, second, ... ninth). To use numerals throughout:
```text theme={null}
{{ ordinal_number(variablename, use_word=False) }}
```
### Numbers written as words
Convert a number to its written-out English form (recommended with the Integer question type):
```text theme={null}
{{ numbers_to_words(variablename) }}
```
Output: *One Hundred Thousand*
### International number formatting
```text theme={null}
{{ format_number_eu(variablename) }}
```
Output: *1.000.000,00* (European convention — periods as thousand separators, comma as decimal)
For Canadian French formatting:
```text theme={null}
{{ "{:,.2f} $".format(variablename).replace(",", " ").replace(".", ",") }}
```
Output: *1 000 000,00\$*
### Rounding in document templates
Round down (floor) to two decimal places:
```text theme={null}
{{ (variable)|round(2, 'floor') }}
```
Round up (ceiling) to two decimal places:
```text theme={null}
{{ (variable)|round(2, 'ceil') }}
```
When combining rounding with other number formatting, place the rounding call *inside* the parentheses:
```text theme={null}
{{ "{:,.0f}".format(variablename|round(0,'ceil')) }}
```
***
## Formatting special numbers
Use `number_custom()` to force specific punctuation patterns on any number. Have the client enter the value as a **Number** question type, then apply the mask in your template using `n` for each digit position.
```text theme={null}
{{ number_custom(variablename, "(nnn) nnn-nnnn") }}
```
Output: *(555) 555-5555*
```text theme={null}
{{ number_custom(variablename, "nnn-nnn-nnnn") }}
```
Output: *555-555-5555*
SSN with dashes:
```text theme={null}
{{ number_custom(variablename, "nnn-nn-nnnn") }}
```
Output: *123-45-6789*
SSN with first five digits masked:
```text theme={null}
{{ number_custom(variablename, "XXX-XX-nnnn") }}
```
Output: *XXX-XX-6789*
```text theme={null}
{{ number_custom(variablename, "nn-nnnnnn") }}
```
Output: *12-3456789*
***
## Formatting words
These functions control capitalization and text transforms. If you want the output to match exactly what the client typed, you do not need any of the functions below.
### Case transforms
```text theme={null}
{{ variablename|upper }}
```
or
```text theme={null}
{{ variablename.upper() }}
```
```text theme={null}
{{ title_case(variablename) }}
```
```text theme={null}
{{ capitalize(variablename) }}
```
```text theme={null}
{{ variablename|lower }}
```
or
```text theme={null}
{{ variablename.lower() }}
```
### Articles and plurals
Add "a" or "an" before a variable automatically:
```text theme={null}
{{ indefinite_article(variablename) }}
```
Output: *An apple* / *A pear*
Pluralize a noun based on a count variable:
```text theme={null}
{{ quantity_noun(variablename, "apple") }}
```
Where `variablename` is an Integer. Output: *1 apple* / *3 apples*
### Punctuation
Add a trailing period only when the text does not already end with one (useful for company names):
```text theme={null}
{{ fix_punctuation(variablename) }}
```
### Verb conjugation
To conjugate a verb based on whether one person, multiple people, or a third-party singular is acting:
1. Create a multiple-choice question with variable name `conjugation` and choices: `1sg`, `3sg`, `pl`.
2. Use this syntax in your template (replacing `allege` with your verb):
```text theme={null}
{{ verb_present('allege', conjugation) }}
```
Output: *allege* (1sg), *alleges* (3sg), or *allege* (pl).
Alternatively, use basic conditional logic:
```text theme={null}
allege{% if singular %}s{% endif %}
```
***
## Formatting text area questions
Text area variables require special handling to preserve line breaks in the output.
```text theme={null}
{{ variablename|manual_line_breaks }}
```
```text theme={null}
{%p for line in VariableName.split("\n") %}{{ loop.index }}. {{ line }}{%p endfor %}
```
```text theme={null}
{%p for line in VariableName.split("\n") %}- {{ line }}{%p endfor %}
```
```text theme={null}
{{ commalist(VariableName.split("\n"), "<__str__()>", "") }}
```
Useful when a client enters a multi-line address and you need to output it inline, such as: *Jane Doe, 123 Main Street, Minneapolis, MN 55436*.
***
## Formatting Multi-Select questions
Multi-Select questions have several output formats you can use in Word document templates.
**As a bulleted list:**
```text theme={null}
{% for item in variablename.true_values() %}
- {{ item }}
{% endfor %}
```
**Count the number of selections:**
```text theme={null}
{{ variablename.number() }}
```
**Conditional on number of selections:**
```text theme={null}
{% if variablename.number() > 2 %}You chose more than 2!{% endif %}
```
**Preserve the order you defined (non-alphabetical):**
```text theme={null}
{% for key, value in variablename.elements.items() if value %}{{ key }} {% endfor %}
```
# Formatting Questions
Source: https://helpdocs.gavel.io/workflows/formatting-questions
Use previous supplied answers in your questions and choices. Customize the formatting and fonts throughout your workflow questions — including bold, italics, headings, links, bullets, accordions, and more.
## Using prior answers inside questions
In addition to show/hide logic, you can reference a prior answer directly inside the text of a later question. This is useful for personalizing question wording or confirming what the client previously entered.
Use the `${VariableName}` syntax anywhere in a question's label, helper text, or answer choices:
```text theme={null}
Hello ${ClientFirstName}. What is your current mailing address?
```
You can also use a prior answer as one of the selectable choices in a multiple-choice question. For example, if an earlier question collected a spouse's name in `SpouseName`, you can offer it as a choice later:
```text theme={null}
Who should be named as the primary beneficiary?
A. ${SpouseName}
B. A trust
C. Other
```
If the client entered "Richard" for `SpouseName`, Choice A will display as "Richard" in the questionnaire.
***
## Showing conditional text inside a question
You can display different text within a question's instruction block based on a prior answer. Use this pattern in an Instruction block:
```text theme={null}
${ "You are married" if MaritalStatus == "Married" else "You are not married" }
```
For more complex conditional content — such as showing entire paragraphs — use Instruction blocks together with Calculations (Invisible Logic). You can also show inline messages that depend on calculations:
```text theme={null}
${ "You do not qualify. Please stop." if ((Income + Assets) < 10) else "You qualify. Please proceed." }
```
Date-based conditions work the same way:
```text theme={null}
${ "We are sorry. You are too late." if date_difference(starting=FilingDate).days > 30 else "Great. Let's continue." }
```
***
## Specialized Formatting
Document formatting can be done directly in the document using standard Word features, so you will not need the instructions below for document formatting.
Customize the formatting and fonts throughout your workflow using rich text formatting in Markdown. Almost anything is possible formatting-wise. If you don't see it below, you can ask us or check out the options [here](https://www.markdownguide.org/basic-syntax/).
### Customize fonts in your questions
| If you write | It will display |
| ------------------------------- | ----------------------------- |
| `*My italic text*` | *My italic text* |
| `**My bold text**` | **My bold text** |
| `***My bold and italic text***` | ***My bold and italic text*** |
| \`\`emphasized` text` | `emphasized` text |
***
### Add grey line dividers
To add grey line dividers between phrases, use three or more dashed lines on a separate line, separated by hard returns like so:
```markdown theme={null}
Some text above
---
Some text below
```
This will output a horizontal divider between the two sections.
***
### Add a hyperlink
If you write:
```markdown theme={null}
[Link text here](https://www.gavel.io)
```
It will display: [Link text here](https://www.gavel.io)
If you would like it to open in a new tab:
```html theme={null}
Link Text Here
```
### Add a Button hyperlink
You can add a button anywhere in your interview workflow to link to any site, like this:
```markdown theme={null}
${ action_button_html("https://www.gavel.io", label="Visit our web site") }
```
Replace the items in quotations with your link and what you want the text to look like.
***
### Add bullet points
Use the `*` sign and skip a line to add a bullet point, like this:
```markdown theme={null}
* Bullet 1
* Bullet 2
```
***
### Add additional line breaks
Use `
` to add a line space, like this:
```markdown theme={null}
Some text here
Some text here
```
***
### Change the sizing of questions
Use `#` signs to increase or decrease the standard size of the font on the questionnaire. For example, using:
```markdown theme={null}
# Heading
## Subheading
### Sub-subheading
```
***
### Create an "Email To" link
To allow someone to click on your link and have it open up an email address, use the following:
```html theme={null}
email@example.com
```
***
### Create a "Call Phone Number" link
To allow someone to click on your link and have it attempt to call a phone number, you can use the following:
```markdown theme={null}
[555-555-5555](tel:5555555555)
```
***
### Create a collapsible section of text (accordion)
The following will allow you to create a collapsible section. Replace only the text inside the tags below:
```html theme={null}
Click to expand!
Collapsed text here.
```
## Incorporate Videos and Files
Embed videos, images and files on the pages of your workflow to provide users more guidance or visuals.
### Add Videos to your workflow
To embed a YouTube or Vimeo video into your workflow, you should:
1. Go to your YouTube or Vimeo video, and get the shareable link.
2. Use the ID of that URL (the end of the URL) between brackets like this: \[YOUTUBE urlhere] or \[VIMEO VideoIDhere] and add this where you want the video to appear in your workflow.
###### Example:
If your URL is [https://youtu.be/ee1j5a1\_Stk](https://youtu.be/ee1j5a1_Stk), you will use: \[YOUTUBE ee1j5a1\_Stk].
### Add Images to your workflow
Images work the same way, except that you first need to load your image as follows:
1. Add your image file to Gavel under Dashboard > Files > Images
2. Reference the file name where you want it to appear in your questionnaire like this:
###### \[FILE FileName.png]
If you want your file to be larger, you can amplify it to a certain percentage of the original file. For example, the following will render an image that is 200% of the original file size:
\[FILE FileName.png, 200%]
### Add Documents and Document Previews
Adding Word or PDF documents within your questionnaire allows you to provide your users with supplemental materials or display document previews before collecting payment. To add a document preview into your workflow, you should:
1. Add the document to your workflow under Documents Templates
2. Reference the file name where you want it to appear in your questionnaire like this:
`${DocumentName}`
You can specify the file type displayed by adding the file type extension to the end of the document name, like this:
`${DocumentName.docx}` `${DocumentName.pdf}`
Your users can click on the document preview to download the file.
If you do not want to generate a copy of these documents at the end of the workflow, you can hide them using [output document logic](https://helpdocs.gavel.io/workflows/document-settings).
# Intro To Document Automation
Source: https://helpdocs.gavel.io/workflows/introduction
Learn how Gavel Workflows combine a questionnaire with document templates to automate legal document generation without writing code.
Gavel is a no-code document automation platform built for legal professionals. A **workflow** is the core building block: it pairs a questionnaire — a series of questions you define — with one or more output document templates. When someone fills out the questionnaire, Gavel uses their answers to generate a fully populated document in seconds. No find-and-replace, no copy-paste. Accurate, automated documents are generated every time.
## How a workflow is structured
Every Gavel workflow has two sides that work together.
A step-by-step web form you build in Gavel's workflow editor directly in the browser. Each question has a unique variable name. The person filling out the workflow — you, a colleague, or a client — answers the questions on screen.
One or more Word (.docx) or PDF templates you connect to the workflow. You tag each template with variable names that match your questions. When the questionnaire is submitted, Gavel merges the answers into the templates automatically.
## The two-step build process
Building a workflow follows a consistent two-step pattern regardless of complexity.
Add questions that capture all the data your documents need. Each question type — text, date, yes/no, single select, and more — maps to a unique variable name. You can organize questions across multiple pages and sections, add conditional logic to show or hide questions based on prior answers, and include instructional blocks or kickout pages for decision-making flows.
Upload your Word or PDF templates and tag them with the variable names from your questionnaire. For Word documents, you insert variable tags directly in the document using Gavel's Word Add-in. For fillable PDFs, you map fields in Gavel's PDF Tagger. You can add conditional clauses, calculations, and repeating-item loops to control exactly how the answers appear in the finished document.
You can connect multiple output documents to a single workflow. For example, a contract workflow might generate a main agreement, an exhibit, and a signature document all from one questionnaire.
## Common use cases
Gavel workflows are flexible enough to serve very different purposes depending on how you configure sharing and access.
| Use case | Description |
| ------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------- |
| **Internal drafting** | You and your team fill out the questionnaire to generate documents without sending anything to a client. |
| **Client intake (multi-user)** | A client fills out the questionnaire to provide their information; you review the data and generate documents in-house. |
| **Client-facing portal** | Clients access and complete the workflow directly, receiving generated documents immediately on the output page. |
| **Decision trees** | Logic-driven workflows that guide users to a decision or recommendation rather than (or in addition to) producing documents. |
| **Paid workflows** | Add a Stripe payment gate (before starting the questionnaire or before generating documents) to monetize your automated legal products. |
## What you can build
Legal professionals use Gavel for a wide range of document types: estate planning documents, business formation packages, lease agreements, demand letters, client intake forms, compliance checklists, and more. Because Gavel works with standard Word and PDF templates, any document you currently draft manually can become an automated workflow.
Build and test your first workflow step by step.
Explore use cases and examples across practice areas.
# Other Integrations
Source: https://helpdocs.gavel.io/workflows/other-integrations
Connect Gavel to other platforms using their native integration with Gavel.
## Using DecisionVault and Gavel Together
Are you using DecisionVault for client intake and Gavel for document automation? Here's what you need to know about integrating Gavel and DecisionVault.
Build a workflow with all the questions you'll need to fill out your document(s). Since you'll be pulling data from DecisionVault, name your fields to match the DecisionVault fields as closely as possible. You can still include additional fields in Gavel that don't exist in DecisionVault.
Use the Word add-in to automate your template against the fields you just created.
Create matching fields on the DecisionVault side.
DecisionVault can push information directly into regular variables in Gavel. For repeating items, DecisionVault can push any number of contacts into those fields.
Reach out to [help@gavel.io](mailto:help@gavel.io) if you're a DecisionVault and Gavel user. We can add a special workflow to your account that's already built to match DecisionVault's default fields, so you can see the integration in action right away.
***
## LegalServer Integration
Use API integration to connect your LegalServer account to Gavel and automate documents directly from LegalServer.
Go to [LegalServer and Gavel Integration](https://help.legalserver.org/article/1845-gavel) to learn more about how to implement this integration through LegalServer.
# Pages and Sections
Source: https://helpdocs.gavel.io/workflows/pages-and-sections
Use pages and sections in Gavel to break your questionnaire into logical screens, group related questions, and include review pages.
A Gavel Workflow is not a single long-scrolling form — it is organized into pages, each representing one screen the respondent sees. Within a set of pages, you can create **sections** to group pages under a common heading, giving respondents a clear sense of structure and progress. Getting your page and section structure right makes the questionnaire easier to complete and reduces the chance of errors.
***
## Pages
### What a page is
Each page in your workflow is a separate screen in the questionnaire. When a respondent clicks **Continue**, they move from the current page to the next. You decide how many questions appear on each page and in what order. A simple workflow might have three or four pages; a detailed intake form might have fifteen or more.
Repeating Item questions must always be placed on their own dedicated page, separate from other questions. Create a new page before adding a Repeating Item question type.
### Adding a page
To add a new page to your workflow:
1. In the Builder's left sidebar, click **+ New**.
2. Select **Page**.
The new page appears in the sidebar and becomes the active editing canvas. You can then add questions to it as usual.
### Reordering pages
Drag pages up or down in the left sidebar to reorder them. The order in the sidebar is the order respondents will encounter them in the questionnaire.
### Deleting a page
To remove a page:
1. Select the page in the sidebar.
2. Click the **delete icon** on the page.
Deleting a page is permanent and cannot be undone. Any questions on that page will also be deleted. Make sure you have moved or noted any questions you want to keep before deleting.
### Page titles
You can give each page a title. The title appears as a heading at the top of the page in the questionnaire, helping respondents understand what the page is about. Use clear, plain-language titles like "Your personal information" or "Details about the property."
***
## Sections
### What a section is
Sections are groupings of pages. They appear in the questionnaire as a labeled stage or category in the progress indicator, helping respondents understand which part of the overall workflow they are in. For example, a complex estate planning questionnaire might have sections like "Personal Information," "Assets," "Beneficiaries," and "Document Preferences."
Sections do not add new screens — they simply label and group the pages that already exist. From a respondent's perspective, sections appear as navigational context, not as a separate step to complete.
### Adding a section
To create a new section:
1. In the Builder's left sidebar, click **+ New**.
2. Select **Section**.
3. Give the section a name in the pop-up that appears.
4. The currently selected page is automatically grouped into the new section.
You can see section assignments at a glance in the left sidebar, which displays which pages belong to which sections.
### Moving pages between sections
To reassign a page to a different section, drag pages up or down in the left sidebar to the section you prefer. Pages within a section are displayed in the sidebar under the section's heading, making it easy to see the overall questionnaire structure.
***
## Review pages
### The default review page
By default, Gavel includes a **Review Page** at the very end of every workflow. On this page, respondents can see all their answers, navigate back to any earlier page to edit their responses, and re-run the document generation. This built-in review step is a safety net that prevents errors from making it into the final documents.
If your workflow design does not require a review step — for example, a very simple single-page form — you can remove the default review page through the workflow settings.
### Custom review pages
You can create additional review pages at any point in the workflow, not just at the end. This is especially useful for long forms where you want respondents to confirm a section before moving on.
**To allow editing of a specific prior answer**, add an Instruction question to your workflow and insert the following syntax, replacing the placeholders with your own values:
```text theme={null}
[Custom link text](${ url_action('VariableName') })
```
**Example:**
```text theme={null}
[Click here to go back and edit your name.](${ url_action('ClientFullName') })
```
This places a clickable link in the questionnaire that returns the respondent to the page where that variable was collected.
### Review pages for repeating items
If your workflow includes Repeating Item questions, you can create a dedicated review page for each repeating item. This lets respondents see a summary of all the entries they have added and edit or add more before proceeding.
To add a repeating item review page, create a new **Instruction** question at the appropriate point in your workflow and enter the following, replacing `ItemName` with your repeating item's variable name:
```text theme={null}
${ hsl_ItemName_table }
${ ItemName.add_action() }
```
This displays a table of all collected entries for that repeating item, along with a control for adding or editing entries.
***
## Tips for good questionnaire structure
Group questions about the same subject together on one page. This reduces cognitive load and makes it easier for respondents to focus.
If your workflow has more than eight to ten pages, use sections to break it into named stages. Respondents will feel more oriented and less overwhelmed.
Always put Repeating Item questions on their own page. Mixing them with other questions is not supported.
Click "Run" to walk through your questionnaire from start to finish. Pay attention to where page breaks feel abrupt or where a section heading would help.
# Bundles: Productization
Source: https://helpdocs.gavel.io/workflows/paywalls
Collect payment before clients access workflows or generate documents by connecting Stripe Connect to a Gavel bundle and testing with Stripe test cards.
Gavel uses **Bundles with Stripe Connect** as the standard way to collect payment from clients. You create a bundle, set a flat-rate price, connect your Stripe account, and choose exactly where in the workflow sequence the payment step appears — before the client begins, or just before documents are generated. This page walks you through the full setup and explains how to test your paywall before going live.
The older **Stripe Paywall Question** feature is deprecated. Existing workflows that use it will continue to work, but you cannot add new Stripe Paywall Questions to new workflows. If you have an existing workflow with a legacy Stripe question that you want to include in a bundle, remove the old paywall question first, then configure pricing through the bundle instead.
***
## Step 1 — Connect Stripe to your Gavel account
Before you can charge clients, you need to link a **Stripe Connect** account to Gavel. This is a separate onboarding from a standard Stripe account.
Go to the **Bundles** page from the Dashboard and click **+ New Bundle**. Fill in the bundle name and description, select at least one workflow, and click through to the **Bundle Pricing** step.
Choose **Flat Rate** as the pricing option. If your Stripe Connect account has not yet been linked, Gavel displays a yellow banner with a link to begin Stripe onboarding.
Click the link in the banner. You will be taken through the Stripe Connect setup flow — entering your business details, bank account information, and identity verification. Once you complete onboarding, Stripe redirects you back to your Gavel bundles page automatically.
If you previously used the legacy Stripe integration (Stripe Paywall Questions), you connected a standard Stripe account at that time. To use bundles with Stripe Connect, you will onboard a Stripe Connect account, which links through your existing Stripe account.
***
## Step 2 — Configure the payment step
Once Stripe Connect is linked, you set the price and decide where in the user's journey payment is collected.
With Stripe connected, enter the amount you want to charge. Gavel currently supports a single flat-rate price per bundle.
Select where the payment step appears:
* **Before the beginning of a workflow** — the client pays before they can start any workflow in the bundle.
* **Before documents are generated** — the client completes the questionnaire first, then pays before receiving their documents.
You can add more than one payment step by clicking **Add another payment step**, allowing you to charge at multiple points (for example, a deposit before starting and a final payment before document delivery).
Click **Finalize** to save. Your bundle is now live with payment gating enabled.
***
## Step 3 — Share or embed the paid bundle
Once your paid bundle is configured, share it with clients in one of two ways:
Click the **copy** icon next to the bundle on the Bundles page and paste the URL into an email or website button. Clients who open the link see the bundle's start page and pricing before they begin.
Click the **Generate Code** icon (``) on the Bundles page to get HTML snippets you can embed on any web page. The card displays the bundle name, description, and a call-to-action button.
***
## Step 4 — Test your paywall
Before sharing a paid bundle with real clients, test the payment flow to confirm it works correctly.
If you are using a legacy Stripe Paywall Question, ensure the **Test Mode** checkbox is checked on the Stripe payment question in your workflow builder. For bundles with Stripe Connect, use your Stripe dashboard's test mode environment.
Open the bundle link or click **Run** on the Bundles page to start the workflow as a client would.
When the payment screen appears, use Stripe's test card numbers. A commonly used test Visa card is:
| Field | Value |
| ----------- | --------------------- |
| Card number | `4242 4242 4242 4242` |
| Expiry | Any future date |
| CVC | Any 3-digit number |
| ZIP | Any 5-digit number |
Stripe provides a full list of test card numbers for different scenarios (declines, authentication challenges, etc.) in their documentation.
Confirm that the payment step appears at the correct point in the workflow and that the workflow proceeds as expected after a successful test payment.
If you are using a legacy Stripe Paywall Question, uncheck **Test Mode** on the question before sharing the workflow with real clients. For Stripe Connect bundles, ensure your Stripe account has completed live mode onboarding.
Test payments do not create real charges, but they do create test records in your Stripe dashboard. Verify you are in Stripe's **test mode** view when reviewing those records — live mode will not show test transactions.
***
## Viewing payments in Stripe
After real clients complete payments, all transaction data is available in your Stripe dashboard at [dashboard.stripe.com](https://dashboard.stripe.com). Use the toolbar to navigate to:
* **Products** — your Gavel bundles appear here as Stripe products
* **Payments** — a log of every charge
* **Customers** — client records created when they pay
* **Reports** — revenue summaries and exports
# PDF Tagger
Source: https://helpdocs.gavel.io/workflows/pdf-forms
Upload a fillable PDF, tag each field to a workflow variable, handle checkboxes and conditional logic, and map repeating item data to specific fields.
If you regularly fill out the same court forms, client intake PDFs, or standard legal forms, Gavel can automate the process entirely. You upload a fillable-field PDF, open the PDF Tagger to connect each field to a variable in your workflow, and from then on Gavel populates the form automatically whenever a user completes the questionnaire. There is no need to type into the PDF manually — every tagged field is filled in based on the answers provided.
## How it works at runtime
When a user finishes the questionnaire and Gavel generates documents, it reads each PDF field's tag and substitutes the corresponding questionnaire answer into that field. Fields tagged to a variable receive the variable's value. Fields tagged with a conditional value receive the text that matches the condition. Fields marked as **Untagged** are left blank. The result is a filled PDF that looks as though it was completed by hand.
## Prepare your PDF
Your PDF must have fillable fields before you can tag it in Gavel. If your PDF does not already have fillable fields, you have two options:
* **Adobe Acrobat Pro** — the standard tool for adding text fields, checkboxes, and signature fields to any PDF.
* **PDF Unlocker and Field Renamer** — Go to: `start.gavel.io/pdf` to unlock your PDF, add text fields, checkboxes, or signature fields.
## Tag PDF fields
Open your workflow and go to the **Document Templates** tab. Upload your fillable PDF. It will appear in the list of templates attached to the workflow.
Click **Tag** on the right side of the PDF document template. This opens the PDF Tagger, which displays your PDF with all its fillable fields visible and selectable.
Click on any fillable field in the PDF. A panel appears with four options for what to put in that field.
Select the appropriate option for that field (see below), configure the value, and click **Save**. Repeat for all fields you want to tag.
## Field tagging options
For each fillable field in your PDF, you have four choices:
Maps the field directly to a workflow variable. When the questionnaire is completed, the field is filled with the answer to that question.
**How to use:** Select the field, choose **Insert Variable**, pick the variable from the list, and click **Save**.
Lets you define rules that determine what text appears in the field based on how other questions were answered. Useful when the content of a field depends on a yes/no answer or a selection elsewhere in the questionnaire.
**How to use:** Select the field, choose **Insert Conditional Value**, build the condition using the available variables, and click **Save**.
Places static text that always appears in this field, regardless of questionnaire answers. You can also use this option to enter advanced formatting syntax (see below).
**How to use:** Select the field, choose **Enter Text**, type the text or syntax you want, and click **Save**.
Leaves the field blank in all generated documents. Use this for fields you intentionally want to leave empty.
## Checkboxes
Gavel can check or uncheck PDF checkboxes based on questionnaire answers.
To check a box conditionally based on a workflow answer:
1. Select the checkbox field in the PDF Tagger.
2. Choose **Insert Conditional Value**.
3. Build the condition — for example, "check this box if the variable `hasChildren` equals Yes."
4. Click **Save**.
Repeat for each checkbox that depends on a variable.
If a box should always be checked regardless of questionnaire answers:
1. Select the checkbox field in the PDF Tagger.
2. Choose **Enter Text**.
3. Type `Yes` in the text field.
4. Click **Save**.
## Advanced formatting with Enter Text syntax
When you choose **Enter Text**, you can enter Gavel formatting syntax to apply calculations, transformations, or conditional logic to the field value. PDF syntax is slightly different from Word syntax:
| Context | Syntax format |
| ------------- | -------------------------------- |
| Word document | `{{ capitalize(TextVariable) }}` |
| PDF field | `${ capitalize(TextVariable) }` |
PDF syntax uses a single set of curly brackets with a dollar sign instead of double curly brackets. To build the correct syntax:
1. Use the Word add-in or the [Formatting Questions page](https://helpdocs.gavel.io/workflows/formatting-questions) to generate the syntax you need.
2. Remove one set of brackets and add a `$` before the remaining opening bracket.
3. Paste the result into the **Enter Text** field.
For example, to format a number as currency in a PDF field, enter:
```text theme={null}
${ currency(numbervariable) }
```
### Splitting a number across multiple fields
Some forms — such as those with a Social Security Number or phone number — use separate fields for different digit groups. You can split a number variable across fields using slice notation:
```text theme={null}
${ str(NumberVariable)[0:3] }
```
In this example, `0` is the start position and `3` is the end position (the first through fourth characters). Adjust the start and end positions for each field to match the digit groupings in your form.
PDF syntax is mostly the same as the simple variable syntax used in workflow question logic, so you can reuse the same expressions you use when [referencing prior answers in the questionnaire.](https://helpdocs.gavel.io/workflows/formatting-questions)
## Repeating items in PDF fields
If your questionnaire includes a repeating item (for example, a list of parties or assets), you can tag PDF fields to specific instances of those repeating values. Open the PDF Tagger, select the relevant field, and choose the repeating item variable and the instance you want to map to that field.
PDFs have a fixed layout — there is no way for Gavel to dynamically add rows or pages to a PDF the way it can in a Word document. Plan your PDF form with a fixed number of rows for repeating data, and map each row's fields to the corresponding repeating item instance.
## Adding fillable fields to a PDF that has none
If your PDF does not have any fillable fields yet, you need to add them before uploading to Gavel.
Go to the **Document Templates** section of your Gavel dashboard and upload the PDF. Gavel unlocks the PDF structure, making it editable.
After uploading, download the version stored in Gavel. This is the file you will add fields to.
Visit `start.gavel.io/pdf` and upload the downloaded file. Use the PDF Renamer to add text fields, checkboxes, or signature fields where needed.
Upload the updated PDF to your workflow's Document Templates tab and begin tagging.
# Workflows: Show Questions and Pages
Source: https://helpdocs.gavel.io/workflows/question-logic
Control which questions and pages your clients see by adding conditional logic to individual questions or entire questionnaire pages in Gavel.
Question logic lets you build an adaptive interview experience where clients only see questions that are relevant to their situation. Rather than presenting every possible question to every client, you define conditions — based on earlier answers — that determine whether a question or a whole page should appear. This keeps your questionnaire focused, reduces completion time, and prevents clients from being confused by questions that don't apply to them.
Gavel supports logic at two levels: **question-level logic** (show or hide a single question) and **page-level logic** (show or hide an entire page of questions). Both work the same way and can include multiple `AND`/`OR` conditions.
***
## Question-level logic
Question logic controls the visibility of an individual question based on how the client answered a prior question.
In your workflow builder, navigate to the question you want to make conditional. Click the **Edit Logic** button on that question.
In the logic panel, choose whether the question should be **shown** or **hidden** when the condition is met. Then select the variable (from a prior question) and the answer value you want to trigger that behavior.
Click **Add Conditions** to add another rule. You can chain multiple conditions using **AND** (all conditions must be true) or **OR** (any condition must be true) to handle more complex scenarios.
Click on the "X" on the upper right hand side of the Logic Menu. Then be sure to "Save" your workflow.
During the interview, Gavel evaluates the logic in real time — the question appears or disappears based on what the client has already answered.
### Example scenarios
Set the condition on the "Spouse's Name" question to **Show if** `MaritalStatus` equals `"Married"`. Clients who select any other marital status skip the question entirely.
Set the condition on a follow-up explanation field to **Hide if** `HasPriorConviction` equals `False`. Only clients who answered "Yes" to the prior conviction question will see the explanation prompt.
Use **AND** logic: show the "Trust Beneficiary Name" question only if `DocumentType` equals `"Trust"` **AND** `ClientHasBeneficiaries` is `True`. Both conditions must be satisfied for the question to appear.
***
## Page-level logic
Page logic works the same way as question logic, but controls the visibility of an entire questionnaire page. If the conditions are not met, the client skips the page completely — none of the questions on that page are asked, and their variables remain blank.
In the workflow builder, find the page you want to make conditional.
Click the **Logic** icon on the page (it looks like a logic tree or branching diagram).
Choose **Show if** or **Hide if**, then select the variable and answer value. Add additional conditions with **Add Conditions** using **AND** or **OR** as needed.
Click on the "X" on the upper right hand side of the Logic Menu. Then be sure to "Save" your workflow.
Gavel will route clients past this page entirely when the conditions are not satisfied.
Page-level logic is especially useful when you have several questions that all depend on the same prior answer. Rather than adding logic to each question individually, you can group them on a single page and apply one condition to the whole page.
***
## Tips for building reliable logic
Always place the question that supplies the condition *before* the question that depends on it in the questionnaire. Logic can only reference answers from prior questions — not later ones.
If a question is hidden by logic, its variable will be blank in the generated document. Make sure any conditional content in your document template accounts for blank values using `{% if VariableName %}` guards.
You can combine question logic and page logic in the same workflow. A common pattern is to use page logic to route clients into a specialized section, then use question logic within that section to fine-tune which fields appear.
# Question Types
Source: https://helpdocs.gavel.io/workflows/question-types
A complete reference for every question type in Gavel, from basic text and date fields to repeating items, integrations, and invisible logic.
The first step in building any Gavel workflow is adding questions that capture all the information your documents need. Gavel offers a broad set of question types — from simple text fields to integration-powered lookups — so you can collect any kind of data without writing code. You add questions by clicking **+ Question** in the bottom right of the Builder, or by selecting **+ New → Question** in the left sidebar.
Every question you add gets a unique **variable name** that you use to reference it in your output document templates. Choosing clear, consistent variable names from the start makes tagging your documents much easier.
***
## Standard input questions
These are the core question types you will use in most workflows.
A single-line text box. Use this for short answers like names, addresses, or titles.
**When to use:** Any field that requires a brief, free-text response — client name, company name, job title, street address.
**Variable output:** A plain text string inserted directly wherever you place `{{ VariableName }}` in your document.
A multi-line text box. Use this when you expect a longer narrative answer that may span several sentences or paragraphs.
**When to use:** Background facts, description of services, special instructions, or any field where the respondent may need to write multiple sentences.
**Variable output:** A text block. The full content inserts at the variable tag in your document.
A two-option question. The respondent answers Yes or No. This is one of the most useful question types for driving conditional logic — showing or hiding later questions and document clauses based on the answer.
**When to use:** "Does the client have children?", "Is this agreement governed by California law?", "Does the tenant have a pet?"
**Variable output:** The value `True` (Yes) or `False` (No). Use this in conditional statements in your document template.
A numeric input field. Gavel supports both whole numbers and decimals. Use this for counts, dollar amounts, percentages, or any value you may need to calculate with.
**When to use:** Purchase price, number of shares, interest rate, term in months.
**Variable output:** A numeric value. You can use number variables in calculations within your document templates.
A date picker. Respondents select a date from a calendar interface.
**When to use:** Effective date, signing date, deadline, date of birth, expiration date.
**Variable output:** A formatted date value. You can control date formatting in your document template.
A text field that validates the entry as a properly formatted email address.
**When to use:** Client email address, contact information, notification recipient.
**Variable output:** A plain text string (the email address).
***
## Choice questions
Use these when you want to constrain the respondent to a set of pre-defined options.
Displays a list of options as radio buttons or clickable tiles. The respondent can choose exactly one option.
**When to use:** State of formation, entity type (LLC, Corporation, Partnership), marital status, payment method.
**Variable output:** The text of the selected option.
Displays a list of options as checkboxes. The respondent can select all options that apply.
**When to use:** Services included in a contract, applicable jurisdictions, rights granted in a license, list of conditions.
**Variable output:** An object containing all selected choices. You can output selected choices as a comma-separated list, a bulleted list, or table rows. See [Multi-Select responses](/workflows/question-types#multi-select-in-documents) below for syntax details.
Functionally identical to Single Select — the respondent chooses one option — but displayed as a collapsed dropdown menu rather than an expanded list. Useful when you have a long list of options and want to save screen space.
**When to use:** Country selection, U.S. state, long lists of standardized options.
**Variable output:** The text of the selected option.
A hybrid input that lets the respondent either choose from a list of predefined options **or** type in their own answer. This is useful when your list covers most cases but you want to allow exceptions.
**When to use:** "Select a currency or enter another", "Choose a standard clause or write a custom one", any field where an "Other" free-text option is needed.
**Variable output:** Either the selected option text or the free-typed value.
***
## Specialized input questions
An electronic signature field. Respondents sign using a mouse, trackpad, or finger on a touch screen. Works on mobile and tablet devices.
**When to use:** Any document requiring a client or party signature directly within the workflow — consent forms, engagement letters, settlement agreements.
**Variable output:** The signature image, which you can embed in your output document using the variable tag.
Allows the respondent to upload a single file. Accepted file types are: `.pdf`, `.docx`, `.doc`, `.txt`, `.rtf`, `.heic`, `.png`, `.jpg`/`.jpeg`, `.tiff`, `.gif`.
**When to use:** Supporting documentation, prior agreements, ID verification, photos, exhibits.
For full details on embedding uploaded files in output documents, see [Accept file uploads in your Gavel workflow](/workflows/file-uploads).
A looping question group that collects the same set of sub-questions for an undefined number of entries. The respondent adds as many entries as needed.
**When to use:** Any data that could have zero to many instances — children, beneficiaries, assets, parties, shareholders, prior employers.
For full details on setup and document syntax, see [Repeating items: collect list data in workflows](/workflows/repeating-items).
***
## Informational blocks
These are not input questions — they display information or control the flow of the questionnaire without collecting a response.
Displays a block of text with a **Continue** button. The respondent reads the instructions and proceeds. No data is collected.
**When to use:** Welcome messages, legal disclaimers, instructions before a complex section, explanatory context between question groups.
A decision or termination page with no input fields. Use a Kickout Page to route users to a custom message or outcome based on their prior answers — for example, notifying them that they are ineligible, directing them to contact your office, or presenting a decision without generating any documents.
**When to use:** Ineligibility screens ("Based on your answers, you do not qualify..."), expert system endpoints, jurisdiction-specific routing.
***
## Integration questions
Pulls data directly from a [Clio contact or matter record](https://helpdocs.gavel.io/workflows/clio). You can enable predictive autofill so the respondent starts typing a name and Gavel retrieves matching records from Clio. All mapped fields from the Clio record populate automatically.
**When to use:** Workflows that draw on existing client or matter data already stored in Clio, eliminating duplicate data entry.
Lets the respondent search and select a row from an uploaded CSV spreadsheet. All data from that row becomes available as variables in your output documents. The CSV file is managed centrally in your account and can be updated at any time.
**When to use:** Lookup tables (attorney information, fee schedules, jurisdiction-specific provisions), reference data that changes over time but follows a consistent structure.
CSV files must be uploaded under **Files → CSV files** before you can add a CSV Data Source question to a workflow. CSV files are shared across all workflows in your account.
**Steps to add your CSV file to your account**
1. There must be two columns in your CSV. If you only need one column of information, the second column requires a header but can otherwise be blank.
2. From your dashboard, go to Files, CSV files, and then select “Upload New CSV.”
3. Designate Whether the CSV Has Private Data. The Private Data setting restricts access to workflows that use this CSV to Builder Users only. It is checked by default. If you want Organizational Users and Users to be able to answer a CSV Data Source question that uses this file, uncheck the Private Data box.
4. Set the Unique Column: This is a column that contains unique values. It is used internally to pull the latest data during document generation.
5. Set the Display Column: These are the columns that will be displayed to the user taking the workflow for rows matching their input.
6. Set the Searchable Columns: The CSV Data Source question allows you to search the data from one or multiple columns by typing in the search box, and then populating your choice.
**Variable syntax in documents:**
```text theme={null}
{{ CSVVariableName['Column_Name'] }}
```
**Example:**
```text theme={null}
{{ AttorneyName['Address_Line_1'] }}
```
[**Advanced Formatting Options found here.**](https://helpdocs.gavel.io/workflows/clio#advanced-clio-variable-syntax)
***
## Question settings
Every question in Gavel supports additional settings accessible through the **Settings** tab on the question panel:
* **Informational text (info bubble):** Add explanatory text that appears as a help tooltip on the questionnaire, visible to respondents who need clarification.
* **Default value:** Pre-populate a field with a value that appears before the respondent types anything. The respondent can change it.
* **Character limits:** Set minimum and maximum character counts for text inputs.
* **Required / optional:** Control whether the respondent must answer before proceeding.
# Quickstart Guide
Source: https://helpdocs.gavel.io/workflows/quickstart
A step-by-step guide to signing up, building your first workflow, connecting a document template, testing, and sharing with clients.
This guide walks you through building your first Gavel workflow from start to finish. By the end, you will have a working questionnaire connected to an output document — ready to test and share.
Gavel offers a [free trial](https://start.gavel.io/pay?_gl=1*w3sszc*_gcl_aw*R0NMLjE3NzYxMDYxNzAuQ2owS0NRandxUExPQmhDaUFSSXNBS1JNUFpwaFRvRVlHZU8zMXBBeFR6LUVFczBmMEc2NndkTjZzUlBENzhPUHNSTnI2djF2d2EydU1lWWFBakhORUFMd193Y0I.*_gcl_au*MTA0OTQ1MzUxOS4xNzc2MTg0NTQyLjYyNDMzNDQ5OC4xNzc3NDA4NjE0LjE3Nzc0MDg4NDI.) (no credit card needed) so you can build and test before committing to a plan. Visit [gavel.io](https://www.gavel.io) to sign up and learn more.
## Before you start
Have a document you want to automate ready. Ideally, choose something you draft frequently with consistently collected information — names, dates, addresses, and so on. A one-page letter or short agreement is a good starting point.
***
## Build your first workflow
Create your Workflows [Free Trial](https://start.gavel.io/pay?_gl=1*w3sszc*_gcl_aw*R0NMLjE3NzYxMDYxNzAuQ2owS0NRandxUExPQmhDaUFSSXNBS1JNUFpwaFRvRVlHZU8zMXBBeFR6LUVFczBmMEc2NndkTjZzUlBENzhPUHNSTnI2djF2d2EydU1lWWFBakhORUFMd193Y0I.*_gcl_au*MTA0OTQ1MzUxOS4xNzc2MTg0NTQyLjYyNDMzNDQ5OC4xNzc3NDA4NjE0LjE3Nzc0MDg4NDI.), choosing your personalized subdomain (e.g., `yourname`). Verify your email address, and your account will be set up at `yourname.gavel.io`. After signing in to your subdomain, you land on your **Dashboard**, where all your workflows live.
Click **New Workflow** from the Dashboard, and give it a name that reflects the document you're automating (for example, "Client Engagement Letter"). Gavel then asks how you'd like to build it — choose from three starting points:
**Start with questions.** Create your questions and add logic first, then connect them to your Word and PDF templates later. This is the best option if you already know exactly what information you need to collect.
Gavel opens the **Builder View** — the workflow editor where you design your questionnaire and connect documents. Continue to Step 3 below to start adding questions.
**Start with documents.** Upload your Word or PDF template first, and Gavel's AI scans it and suggests questions for each variable it detects — no need to build your questionnaire from scratch.
Upload your Word or PDF template to Blueprint. The AI identifies variable placeholders in your template and suggests a question for each one.
Scroll through the content or use the variable sidebar. Blueprint highlights each location where it detected a variable.
Accept variables that correspond to genuine client-provided data. Reject any that Blueprint identified incorrectly — for example, static text it mistook for a placeholder.
Once you've reviewed all variables, click **Draft Workflow**. Gavel generates a first draft of the workflow, including all accepted variables as questions.
You can edit all question details — wording, type, variable name — after the workflow is generated. There's no need to get every detail perfect during the Blueprint review step! Continue to Step 4 below to organize and refine your questions.
**Select a legal template.** Choose from Gavel's [library of pre-built workflows](https://www.gavel.io/legal-template-library) to generate common documents by practice area and jurisdiction. This gives you a ready-made questionnaire and document template you can customize to fit your needs.
Once selected, the template opens in the **Builder View**, where you can edit questions, pages, and the connected document just as you would with a workflow built from scratch.
You must be on Pro in order to access the Legal Templates.
In the Builder View, add questions that correspond to every piece of variable information in your document. For each question:
1. Click **+ Question** (bottom right) or **+ New → Question** in the left sidebar.
2. Select the appropriate question type (Text, Date, Yes/No, etc.).
3. Enter the Question name (a label your respondent will see).
4. Enter the **Variable Name** (e.g., `ClientFullName`) — you will use this to tag your document template.
Repeat until you have created a question for every field that will need to exist in your output document.
Use descriptive variable names like `ClientFullName` or `EffectiveDate` rather than generic names. You will insert these into your document template, so clarity matters.
Long questionnaires are easier to complete when grouped into logical pages. Click **+ Add Page** (top right) to add a page. Drag questions between pages (using the left sidebar) to arrange them. Each page becomes one screen in the questionnaire experience.
You can also add **sections** to group pages under a heading, which gives respondents a visual sense of progress (each section name will appear on the left while respondents fill out the questionnaire, showing them how far along they are). Some Builders find it easiest to add sections first, then add pages to each section, then add questions to each page.
Navigate to the **Document Templates** tab of your workflow.
1. Install the free **Gavel Word Add-in** from the Microsoft AppSource if you haven't already. Follow [these steps](https://gavelworkflows.mintlify.app/workflows/word-documents#install-the-gavel-word-add-in) to get set up.
2. Open your Word document and use the Add-in to insert variable tags — for example, `{{ ClientFullName }}` — wherever variable content should appear.
3. Save the document and upload it to the Document Templates tab in Gavel.
1. Upload your fillable PDF to the Document Templates tab.
2. Click "Edit Tags" to open the **PDF Tagger**, which displays each form field in your PDF.
3. Map each field to the corresponding variable name from your questionnaire.
4. Save your field mappings.
If you used Blueprint, your template will already have variables mapped from the accept/reject review — check this tab to confirm the mapping looks right before moving on.
You can attach multiple output documents to a single workflow. All connected templates are generated simultaneously when the questionnaire is submitted. You can also set up document logic to only output certain documents depending on the respondent's answers to the questionnaire.
Save your workflow, and click \*\*Run \*\*in the Builder View to run through the questionnaire as a respondent would. Fill in sample answers and proceed to the output page to confirm that the generated documents look correct.
Check that:
* All variable fields populate with the correct answers
* Conditional clauses show and hide as expected
* Formatting in the output document matches your template
Always test before sharing with clients. A quick test run catches missing variables and formatting issues before they reach a real respondent.
Once you are satisfied with the test output, choose how you would like to share your workflow. Depending on how you want to use it, you can:
* **Share a direct link** with specific colleagues or clients
* **Embed the workflow** on your website or client portal
* **Restrict access** to specific users or require login
* **Set it to public** so anyone with the link can complete it
Respondents follow the link and complete the questionnaire. They can receive the generated documents on the output page, or you can hide the output documents and have them emailed to you for review.
***
## Next steps
Now that you have a working workflow, explore more advanced features to make it smarter and more polished.
Learn about all available question types, including text questions, repeating items, and file uploads.
Organize your questionnaire into a clean, navigable structure.
Collect variable-length lists like children, assets, or parties to a contract.
Get inspired by use cases and examples from real legal workflows.
# Ready to Upgrade
Source: https://helpdocs.gavel.io/workflows/ready-to-upgrade
Upgrade your Gavel Workflows plan using Gavel's billing portal — review available plans, select your tier, and complete checkout in a few quick steps.
When you're ready to move beyond the free trial or change your current subscription, you can upgrade your plan directly from Gavel's billing portal. The whole process takes just a few minutes.
## Upgrade your plan
Log in to your Gavel Workflows account. You should see your Dashboard with all of your workflows listed.
From the settings menu, click **Billing** to view your current plan and subscription details.
Review the available plans and click **Select** on the tier you'd like to upgrade to.
You can opt for Monthly or Annually. Annually saves you two months a year in cost!
Review the plan details, billing frequency, and prorated charges, then click **Confirm** to apply the change.
If prompted, enter your payment information. Your upgrade activates immediately once payment is processed.
Have questions about pricing, invoices, or which plan is right for you? [Contact the Gavel Workflows support team](/workflows/contact-us) — we're happy to help you choose the best fit.
# Repeating Items
Source: https://helpdocs.gavel.io/workflows/repeating-items
Use Gavel's Repeating Item question type to collect variable-length lists, nest repeating items, apply conditionals, and count entries in your documents.
Many legal documents require information about a variable number of people or things: a client's children, the parties to a contract, a list of assets in an estate, or the shareholders of a company. You never know in advance how many entries there will be — it could be one or twenty. **Repeating Items** (also called looping lists) are designed exactly for this. A Repeating Item question lets respondents add as many entries as they need, and Gavel loops through all of them to populate your document.
Repeating Item questions must be placed on their own dedicated page. Do not add other question types to the same page as a Repeating Item. Create a new page in the Builder before adding one.
***
## How repeating items work
When you add a Repeating Item question, you define:
* **The item name** — a variable name representing the collection (e.g., `children`, `assets`, `parties`)
* **The attributes** — sub-questions for each entry (e.g., `FirstName`, `dob`, `address`)
The respondent adds entries one at a time, answering the attribute questions for each. Gavel collects all entries and stores them as a list. Your document template then loops through that list to output each entry.
***
## Basic document syntax
Use this pattern in your Word document template to output data from a Repeating Item:
```text theme={null}
{% for item in ItemName %}
{{ item.ItemAttributeName }}
{% endfor %}
```
* `ItemName` — the variable name you gave the repeating item
* `ItemAttributeName` — the variable name of a specific attribute (sub-question)
**Example — children's names and birthdates:**
```text theme={null}
{% for item in children %}
Name: {{ item.FirstName }}
Birthdate: {{ item.dob }}
{% endfor %}
```
### Bulleted or numbered lists
To output repeating item data as a bulleted list, apply Word's list style to the attribute line inside the loop:
```text theme={null}
{% for item in ItemName %}
- {{ item.ItemAttributeName }}
{% endfor %}
```
### Tables
To populate a table in your Word document with repeating item data, add the for/endfor tags to the first and last rows of the table respectively, with attribute variables in the middle rows. Gavel will generate a new table row for each entry in the list.
***
## Reference a repeating item question
Refer to the responses to a prior Repeating Item question in a subsequent question using the two steps below.
### Step 1. Add a "repeating item reference" question to the workflow
1. Once you have created a repeating item question, create a choice question or a Repeating Item with a choice attribute. (Choice questions can be single-select, multi-select, combobox, or dropdown.)
2. Select the **Reference a repeating item** checkbox.
3. Select the repeating item you're referencing and up to two attributes to display.
All the data from the repeating item comes with that selection. If you have a repeating item "children," and a single select question referencing "children," it will pull all the information about that child you gathered in the repeating item. No need to regather that information!
### Step 2. Add variables to the document
Because each repeating item may have multiple attributes (e.g., children could have attributes such as first name, last name, date of birth, residence, etc.), you need to reference the appropriate attribute, which varies depending on the question type.
#### Option 1: Single-select or dropdown question referencing a repeat
```text theme={null}
{{ VariableName.ItemAttribute }}
```
**Example:**
```text theme={null}
{{ favorite_child.child_first_name }} {{ favorite_child.child_last_name }}
```
#### Option 2: Multi-select question referencing a repeat
```text theme={null}
{% for item in MultiSelectVariableName %}{{ item.ItemAttribute }}{% endfor %}
```
**Example:**
```text theme={null}
{% for item in favorite_child %}{{ item.child_first_name }} {{ item.child_last_name }}{% endfor %}
```
To make it a comma list, use the regular commalist formatting:
```text theme={null}
{{ commalist(VariableName, '') }}
```
To count how many items were selected in the multi-select:
```text theme={null}
{% if (MultiSelectVariableName.true_values())|length > 1 %}TEXT HERE.{% endif %}
```
#### Option 3: Repeating Item question referencing a repeat
```text theme={null}
{% for item in SecondItem %} {{ item.ItemAttribute.FirstItemAttribute }} {% endfor %}
```
**Example** — if the second item is `grandchildren` and we're asking who each grandchild belongs to:
```text theme={null}
{% for item in grandchildren %}
{{ item.grandchildname }} is the child of {{ item.grandchildparent.child_first_name }}
{% endfor %}
```
**Example where the attribute is a multi-select:** If the repeating item referencing the first repeating item is a multi-select, the syntax will be slightly different, since a multi-select is a list of items, too.
Use this syntax for a comma list:
```text theme={null}
{% for item in Item2Name %}{{ commalist(item.Item2Attribute,"") }}{% endfor %}
{% for item in grandchildren %}{{ commalist(item.grandchildparent,"") }}{% endfor %}
```
Use this syntax for a multi-line list:
```text theme={null}
{% for item in Item2Name %}{% for selection in item.Item2Attribute %}{{ selection.Item1Attribute }}
{% endfor %}{% endfor %}
{% for item in grandchildren %}{% for selection in item.grandchildparent %}{{ selection.child_first_name }}
{% endfor %}{% endfor %}
```
***
## Nested repeating items
You can add a Repeating Item **inside** another Repeating Item to collect data about sub-lists that belong to each entry in the parent list. For example: a list of children (parent repeating item), where each child may have their own list of grandchildren (nested repeating item).
### Setting up nested repeating items
1. Add a Repeating Item question for the parent list (e.g., `children`). It must be on its own page.
2. Add at least one attribute question to the parent Repeating Item.
3. Click **Add another** within the Repeating Item editor and choose **Repeating Item** as the question type.
4. Give the nested item a name (e.g., `grandchildren`) and add its attribute questions.
You can optionally ask an **initial question** (such as "Does this child have any children?") before the nested entries are collected. This is recommended when the nested list may be empty for some parent entries.
### Page titles for nested items
Because nested Repeating Items always display on their own page during the questionnaire, you can customize the page title to show context from the parent entry. Use the syntax:
```text theme={null}
${ ItemName[i].AttributeName }
```
**Example** — show the child's name when asking about their grandchildren:
```text theme={null}
${ children[i].ChildName }
```
### Nested repeating items in Word documents
```text theme={null}
{% for item in ItemName %}
{% for nesteditem in item.NestedItemName %}
{{ nesteditem.NestedAttributeName }}
{% endfor %}{% endfor %}
```
**Example:**
```text theme={null}
{% for item in children %}
My child {{ item.ChildName }} has the following children:
{% for nesteditem in item.grandchildren %}
Name: {{ nesteditem.FirstName }}
Birthdate: {{ nesteditem.dob }}
{% endfor %}{% endfor %}
```
### Nested repeating items in PDFs
To reference a specific entry from a nested repeating item in a PDF field, use:
```text theme={null}
${ ItemName[#].NestedItemName[##].AttributeName if len(ItemName)># and len(ItemName[#].NestedItemName)>## else "" }
```
* `#` — zero-based index of the parent entry (0 = first, 1 = second, etc.)
* `##` — zero-based index of the nested entry
**Example** — first child's third grandchild's name:
```text theme={null}
${ children[0].grandchildren[2].grandchildname if len(children)>0 and len(children[0].grandchildren)>2 else "" }
```
***
## Conditionals with repeating items
You can write conditional text in your documents based on the number of repeating item entries or on the value of a specific attribute.
### Conditional text based on count
```text theme={null}
{% if ItemName.number() == 0 %}There are no entries.{% endif %}
{% if ItemName.number() > 1 %}There is more than one entry.{% endif %}
```
**Example:**
```text theme={null}
{% if children.number() == 1 %}There is one child.{% else %}There is more than one child or no children.{% endif %}
```
### Conditional text within a loop
```text theme={null}
{% for item in ItemName %}
{{ item.AttributeName }}{% if item.Attribute == "Value" %} Some conditional text.{% endif %}
{% endfor %}
```
**Example** — add a note when a child's gender is female:
```text theme={null}
{% for item in Children %}
The child's name is {{ item.childname }}. {% if item.childgender == "Female" %}She's a female.{% endif %}
{% endfor %}
```
### Filter the loop to only matching items
To output only entries where a specific attribute matches a value:
```text theme={null}
{% for item in ItemName if item.ItemAttribute == "Value" %}
{{ item.AnotherAttribute }}
{% endfor %}
```
**Example** — list only female children:
```text theme={null}
{% for item in Children if item.Gender == "Female" %}{{ item.FullName }}, {% endfor %}
```
### Test whether multiple entries share an attribute
```text theme={null}
{% if ItemName|selectattr("Attribute", "equalto", "Value")|list|length > 1 %}
Conditional text.
{% endif %}
```
**Example** — check if two or more children are female:
```text theme={null}
{% if children|selectattr("childgender", "equalto", "Female")|list|length >= 2 %}
Two or more kids are female.
{% endif %}
```
***
## Counting and referencing specific entries
### Display the total count
```text theme={null}
{{ ItemName.number() }}
```
### Reference a specific entry by position
```text theme={null}
{{ ItemName[0].ItemAttribute }}
```
Remember: the list is zero-indexed. The first entry is `[0]`, the second is `[1]`, and so on.
**Example** — first and third child's name:
```text theme={null}
{{ children[0].firstname }} and {{ children[2].firstname }}
```
### Reference the entry's position within the loop
```text theme={null}
{% for item in children %}{{ item.childname }} is my child number {{ loop.index }}{% endfor %}
```
Output: "Jane is my child number 1. Jill is my child number 2."
### Calculate the sum of a numeric attribute
```text theme={null}
{{ repeating_item_sum(ItemName, "item.ItemAttribute") }}
```
**As currency:**
```text theme={null}
{{ currency(repeating_item_sum(ItemName, "item.ItemAttribute")) }}
```
**Example** — sum the cost of all assets:
```text theme={null}
{{ repeating_item_sum(assets, "item.cost") }}
```
### Advanced position-based text
Add text only when an item is **not** the last in the list:
```text theme={null}
{% if not loop.last %}something{% endif %}
```
Add the word "and" before the second-to-last item:
```text theme={null}
{% if loop.revindex == 2 %} and{% endif %}
```
***
## Tips for working with repeating items
Repeating Item questions cannot share a page with other question types. Create a dedicated page before adding the question.
Use short, lowercase variable names for repeating items (e.g., `children`, `assets`, `parties`). These appear repeatedly in your document syntax.
When there might be zero entries (e.g., "Does this client have children?"), enable the initial question to avoid empty loops in your document.
Always test your repeating item workflow by adding two or three entries. A single entry can mask looping issues that appear with multiple entries.
# Sharing Workflows
Source: https://helpdocs.gavel.io/workflows/sharing
Send a direct link, embed a workflow on your website, password-protect access, and white-label your Gavel account to match your firm's brand.
Once you've built a workflow in Gavel, you have several ways to get it in front of clients, colleagues, or the public. You can share a direct link by email, embed the workflow directly on your website, restrict access with a login requirement or password gate, and apply your firm's branding so that Gavel stays invisible to end users. This page covers all of those options.
## Sharing a workflow link
The quickest way to share a workflow is to copy its direct link and paste it wherever your clients will find it — an email, an intranet page, or a button on your website.
Navigate to your Gavel Dashboard and find the workflow you want to share.
Click the **three dots** (⋯) to the right of the workflow name and select **Copy workflow link**. The URL is now on your clipboard.
Paste the URL into an email, an intranet page, or as the destination of a button on your website. When a recipient clicks the link, they are taken directly to the start of the workflow.
Any workflow that contains a Clio question or a private CSV will return an "Unauthorized" error for users who do not have Builder privileges. To share those workflows publicly, either remove the private data or promote those users to Builder.
### Require login before starting
By default, anyone with the link can access your workflow. If you want answers saved to a user account — and want to be able to assign workflows back to specific people — you can require a login instead.
Go to the **Settings** tab of your workflow, then click **Access Permissions**.
Change the access setting from **Anyone with Link** to **Only Logged-In Users** and save. You can further restrict access to specific email addresses or an entire email domain (for example, everyone at `@yourfirm.com`).
Copy and share the workflow link as usual. When clients click it, they are taken to your Gavel sign-in page. New visitors can create an account, after which they will see the workflow you shared.
### Share from the middle of a workflow
Sometimes you want to fill in the first part of a workflow yourself and then hand it off to your client to complete the rest.
In the workflow **Settings**, enable the **Include Link for User to Continue Later** option.
Fill in the fields you want to pre-populate, then click **Save and Continue Later** inside the workflow. Enter the recipient's email address and Gavel will send them a link to pick up exactly where you left off.
***
## Embedding a workflow on your website
Customers on the **Pro** and **Scale** plans can embed any workflow directly into a web page using an `
```
Adjust the `width` and `height` values to fit your layout.
To have the workflow fill the entire browser window, use this full-page snippet:
```html theme={null}
```
For responsive resizing on WordPress, use the following snippet (requires a Business Plan subscription on WordPress.com):
```html theme={null}
```
Use this snippet for Squarespace — it handles both height and width responsiveness:
```html theme={null}
```
In the Squarespace editor, click **+ ADD BLOCK**, choose **Embed** or **Code**, click the pencil icon, and paste the snippet.
Safari on iOS blocks embedded content from cross-site origins by default (the "Prevent Cross-Site Tracking" setting). Users can disable that setting manually, or you can set up a custom subdomain — once your workflow runs on the same domain as the embedding page, Safari restrictions no longer apply.
***
## Password protecting a workflow
Gavel doesn't have a single password field in Settings, but you can build a lightweight gate using a Kickout Page.
Add a **Text Question** to your workflow and label it something like "Enter password." This is where users will type the passcode.
Add a **Kickout Page** question immediately after. This page will appear when the password is wrong.
In the **Page Logic** for the Kickout Page, set the rule to **Hide If** the password matches the correct value. For example, if your password is `LegalAccess2024`, set the Kickout Page to *Hide If password is LegalAccess2024*.
Run the workflow and verify that entering the wrong password displays the Kickout Page, while entering the correct password hides it and allows the user to continue.
***
## Setting up a custom domain
By default your Gavel account lives at `yourname.gavel.io`. Accounts on the **Pro** and **Scale** plans can map a custom subdomain — for example, `documents.yourfirm.com` — so that the Gavel name never appears in your URLs.
Gavel workflows must reside on their own subdomain. If your main site is at `www.yourfirm.com`, your workflows must be at a different subdomain such as `docs.yourfirm.com` — not at `www.yourfirm.com` itself.
When you created your Gavel account you were assigned a `.gavel.io` subdomain — for example, `yourfirm.gavel.io`. This is your ANAME record.
Decide on the subdomain you want to use, for example `docs.yourfirm.com`.
Log in to your DNS provider (Cloudflare, GoDaddy, Name.com, etc.) and create a CNAME record:
| Field | Value |
| ------ | ------------------- |
| Type | CNAME |
| Host | `docs.yourfirm.com` |
| Answer | `yourfirm.gavel.io` |
| TTL | 300 |
Some providers (like GoDaddy) only want the subdomain portion for the Host field — `docs` rather than the full `docs.yourfirm.com`.
Email [help@gavel.io](mailto:help@gavel.io) with your custom subdomain URL. Allow up to 24 hours (usually less than one hour) for DNS propagation.
On the **Scale** plan you can also send Gavel's automated emails from your own domain via Mailgun. Email [help@gavel.io](mailto:help@gavel.io) with your Mailgun email address, API key, and domain to get that configured.
***
## White-labeling and branding
Gavel gives you several options to make the platform look like your own product rather than a third-party tool.
Under the **Standard**, **Pro**, and **Scale** plans, you can display your own logo in the top-left corner of every workflow. Go to **System Settings** in your Dashboard and upload an image — ideally 200 × 26 pixels.
From the same **System Settings** page you can also upload a custom favicon that appears in the browser tab for all of your Gavel workflows.
If you want clients to land on a branded page that lists all the workflows available to them, you can set up an [Internal Portal](https://helpdocs.gavel.io/workflows/client-portals#internal-portals-—-a-public-page-of-workflows) and email [help@gavel.io](mailto:help@gavel.io) and we can set that to be the landing page.
Your Gavel subdomain (e.g., `yourfirm.gavel.io`) cannot be changed after account creation. However, setting up a custom domain as described above achieves the same result — your workflows will appear under your own domain with no mention of Gavel in the URL.
***
## Add custom styles with CSS
Changing styles with custom CSS is available on **Pro** and **Scale** accounts. If you're on one of these plans, you can match the look and feel of your own website by adding your own CSS to change the styles, colors, fonts, and button styles in your workflow.
### Pre-built custom styles
You can use any of the design themes [listed on Bootswatch](https://bootswatch.com/), or choose from a set of styles Gavel has already built for you:
| Style | Link | Notes |
| -------------------- | -------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
| Gavel Classic Look | [documatecss\_classic.css](https://documate-styles.s3.us-west-1.amazonaws.com/documatecss_classic.css) | |
| Clean CSS Favorite | [cleancss.css](https://documate-styles.s3-us-west-1.amazonaws.com/cleancss.css) | |
| Black and White | [blackwhite.css](https://documate-styles.s3-us-west-1.amazonaws.com/blackwhite.css) | |
| Dark Mode | [darkmode.css](https://documate-styles.s3-us-west-1.amazonaws.com/darkmode.css) | |
| Two Columns | [twocolumns.css](https://documate-styles.s3.us-west-1.amazonaws.com/twocolumns.css) | |
| No Header | [noheader.css](https://documate-styles.s3.us-west-1.amazonaws.com/noheader.css) | Good for embedding if you don't want the top logo/banner showing |
| No Login | [nologin.css](https://documate-styles.s3.us-west-1.amazonaws.com/nologin.css) | Good if you don't want to allow users to log in from the top right, but still want to show the logo |
| No Login (Dark Mode) | [dark\_no\_login\_documatecss.css](https://documate-styles.s3.us-west-1.amazonaws.com/dark_no_login_documatecss.css) | |
| No Email | [NoEmail.css](https://documate-styles.s3.us-west-1.amazonaws.com/NoEmail.css) | Good if you want users to download documents on the final screen but not email them |
| Right to Left | [RightToLeft.css](https://documate-styles.s3.us-west-1.amazonaws.com/RightToLeft.css) | Good for languages read right to left, like Arabic and Hebrew |
### Build your own style
Gavel Expert [Ash Singh](https://www.gavel.io/developers/ash-singh) created a [Gavel Custom CSS Generator](https://www.gavelcustomcssgenerator.com/), where you can change colors and certain formats using his tool. It's easy to use for a nominal fee, and this third-party site will help you create your own custom CSS to add to your Gavel workflows.
The Gavel Custom CSS Generator is an unofficial, third-party project offered by Ash Singh and is not affiliated with Gavel.
### Adding your custom CSS to a workflow
Pick one of the pre-built styles above, use the Custom CSS Generator, or write your own stylesheet.
Go to the **Settings** tab of the workflow you want to style.
Paste the link to your CSS file into the custom styling field in Settings, then save.
***
## Customizing messages and emails
Every on-screen message and automated email that Gavel sends to your users can be rewritten to match your firm's voice. You can include variable names in any message to personalize them dynamically.
Navigate to the **Settings** tab of the workflow you want to customize.
Click **Settings**, then **Customize Messages**.
Toggle between **Questionnaire messages** (displayed on screen) and **Email messages** (sent automatically). Edit the text, add bold or italic formatting, or include multiple paragraphs. Use variable names — such as `${ clientname }` — to insert personalized values.
To include a file upload in a confirmation email or on the final screen, use this syntax — replacing `Display Name` and `FileUploadVariable` with your own values:
```text theme={null}
[Display Name](${ FileUploadVariable.url_for(external=True) })
```
Add `Private=False` if the link should be accessible to users who are not signed in:
```text theme={null}
[Display Name](${ FileUploadVariable.url_for(external=True, Private=False) })
```
***
## Embed Calendly into your workflow
With Gavel, you can embed your Calendly appointments page directly into your Gavel questionnaire to make it easy for your clients to book a meeting with you.
### Embedding a Calendly page
In your questionnaire, create a new **Instruction** question.
In the instruction box, paste the following syntax:
```html theme={null}
```
Replace `CALENDLY LINK` in the syntax above with your own Calendly link.
Click **Save**, then **Run** to see the Calendly link embedded in your workflow.
Your Calendly is now embedded! You can also apply logic to your instruction box if you only want the Calendly page to show up in certain circumstances.
# Troubleshooting
Source: https://helpdocs.gavel.io/workflows/troubleshooting
Help with signing in, managing your account, and resolving common errors.
## Logging In
* Have you done a hard refresh like [this](#hard-refresh)?
* Make sure you're logging in at **\[yoursubdomain].gavel.io**. Bookmark that page for the future.
* Have you [cleared your browser cache](https://support.google.com/google-ads/answer/32050?hl=en-AU\&co=GENIE.Platform%3DDesktop)?
* What device are you on? We recommend using Gavel on your desktop, with Chrome, for the best experience.
* Have you done a password reset? **Make sure you're using the exact same email as the one associated with your account.**
This is your subdomain. So, if your Gavel site is at [mylawfirm.gavel.io](https://mylawfirm.gavel.io), your clientname would be `mylawfirm`.
***
## Account Management
Admins can make billing adjustments from the billing portal in their dashboard by going to **Settings > Billing**. For anything else, email [help@gavel.io](mailto:help@gavel.io).
Is your colleague set as a Builder or an end user? Go to **Users** and check whether they're set as the correct type of user.
Gavel Builders are siloed by design — all Builders do **not** see the same Dashboard. If you'd like your colleagues to use workflows you've created, you need to [send a copy to their Builder seat](https://help.gavel.io/articles/builder-collaboration) or [assign the workflow to them](https://help.gavel.io/articles/assigning-workflows). See [User Management](https://help.gavel.io/articles/user-management) for more info.
If you want to keep all the data in your Data Manager, there's no way to create a new subdomain for your existing account. However, if you're on the Pro plan, you can set up a [custom domain](https://help.gavel.io/articles/custom-domain) to replace the original subdomain URL with something else (e.g., [documents.mynewlawfirm.com](https://documents.mynewlawfirm.com) instead of [oldfirm.gavel.io](https://oldfirm.gavel.io)).
***
## Troubleshooting
Please send [help@gavel.io](mailto:help@gavel.io) the URL of the page you're on and a PDF or screenshot of the full error message. Don't worry, it's fixable! You can also paste the text of the error message into the "Ask Assistant" feature (at the top of this page) for help troubleshooting.
If you're in Data Manager and see "No sessions" but know this workflow has sessions, it likely means there's an error in your workflow. Click **Run** on your workflow and start filling out a test run to trigger the error.
If you need help resolving it, paste the full error message into the "Ask Assistant" feature (at the top of this page) for troubleshooting advice, or email [help@gavel.io](mailto:help@gavel.io) with a PDF or screenshot of the error and the URL of the page you're seeing it on.
This means you're trying to load many or a few large documents and the site timed out in the process. You should be able to come back in a bit and refresh the page to see the document.
Reach out to [help@gavel.io](mailto:help@gavel.io) if this is happening frequently so we can make an adjustment for you.
Try opening the document in another PDF reading tool. Reach out to [help@gavel.io](mailto:help@gavel.io) if you continue to see this issue.
A hard refresh forces your browser to load the latest version of a page by clearing its cached files. Note that clicking the refresh arrow in your address bar is **not** a hard refresh.
| Platform | Shortcut |
| ------------------------------- | --------------------------------------------------------- |
| Windows (Chrome, Firefox, Edge) | `Ctrl + F5` |
| Mac (Chrome, Firefox) | `Cmd + Shift + R` |
| Safari (Mac) | `Opt + Cmd + E` to clear cache, then `Cmd + R` to refresh |
# User Management
Source: https://helpdocs.gavel.io/workflows/user-management
Learn the four Gavel user roles — Admin, Builder, Organizational User, and User — and how to invite and manage team members from the Users page.
Gavel organizes everyone who accesses your account into one of four roles: **Admin**, **Builder**, **Organizational User**, and **User**. Each role defines what a person can see, build, and do. Choosing the right role for each person keeps your client data secure, your workflow library tidy, and your billing under control.
One important principle to keep in mind: **Organizational Users and Users have no access to any workflow by default**. Access must be explicitly granted by an Admin or Builder — either by assigning a workflow directly or by assigning a bundle.
***
## Role overview
**Who it's for:** The person responsible for the Gavel account — typically a firm administrator, managing partner, or operations lead.
The Admin has comprehensive control over every aspect of the account. This role is best held by whoever manages billing and is responsible for onboarding and offboarding team members.
**Key capabilities:**
* Manage billing and account subscription details
* View and manipulate all client data across the entire platform
* Change any user's role and contact information
* Invite and deactivate users
* Perform every action available to a Builder — create, edit, share, and assign workflows and bundles
**Things to know:**
* It is recommended that an account has only one Admin seat, since the Admin controls the billing portal and payment for Gavel services.
* An Admin can still build and test workflows just like a Builder.
* To cancel your Gavel account, the Admin should follow the account cancellation process.
**Who it's for:** Attorneys, paralegals, or consultants who create and manage document automation workflows.
Builders are the practitioners who design questionnaires, upload document templates, configure logic, and share completed workflows with clients or colleagues. They can see and work with the client data that flows through their own workflows.
**Key capabilities:**
* Create and edit workflows, questionnaires, and document templates
* Share workflows with clients via link or direct assignment
* Assign workflows to specific users and revoke that access
* Collaborate with other Admins and Builders by sharing a workflow — sending a copy for a colleague to edit, run, or share (see [Builder Collaboration](#builder-collaboration) below)
* Access and manipulate client data associated with their workflows
**Things to know:**
* A Builder cannot manage billing or change other users' roles — that requires the Admin.
* If you are working with an outside consultant or Gavel Expert to build your workflows, you can add them as a Builder. Many experts prefer to build on their own Gavel account and transfer workflows to yours when ready — discuss this approach with your consultant.
**Who it's for:** Power users who need to run workflows repeatedly — such as a paralegal at a partner firm, a high-volume client, or a B2B customer who licenses access to your automation.
An Organizational User can answer assigned workflows and reuse the data they enter across multiple sessions. Unlike the end-user **User** role, an Organizational User can run the same workflow again with new data each time.
**Key capabilities:**
* Complete workflows assigned to them by an Admin or Builder
* Generate documents by answering the questions in those workflows
* Access and edit their submitted data in Data Manager to make corrections or generate updated documents
**Things to know:**
* Organizational Users cannot create or edit workflows.
* They only see workflows that have been explicitly assigned to them.
* This role does not require the person to be inside your firm. Many Gavel accounts use this role for B2B purposes — selling access to a workflow package to another law firm or business.
**Who it's for:** Individual clients who need to answer a questionnaire once and receive their documents.
The User role is the lightest-weight role, designed for one-time or infrequent use. Users interact only with their client portal and only see what you have assigned to them.
**Key capabilities:**
* Access and respond to assigned workflows in their client portal
* Have their answers saved automatically (data persistence)
**Data persistence:** If a User has previously entered a value for a variable — for example, their name as `clientname` — every other workflow that uses the `clientname` variable will automatically populate with the same value. Users never need to re-enter the same information.
**Things to know:**
* A User cannot run the same workflow again with new data. Their session is saved and persists.
* Users only see workflows and data that you have assigned to them — nothing else is visible.
* You can have **unlimited** Users on your account.
***
## Role comparison at a glance
| Capability | Admin | Builder | Org. User | User |
| -------------------------------- | :---: | :-----: | :-------: | :--: |
| Manage billing | ✓ | | | |
| Manage user roles | ✓ | | | |
| Create & edit workflows | ✓ | ✓ | | |
| Assign workflows to others | ✓ | ✓ | | |
| Access all client data | ✓ | | | |
| Access own assigned data | ✓ | ✓ | ✓ | |
| Run assigned workflows | ✓ | ✓ | ✓ | ✓ |
| Re-run workflows with new data | ✓ | ✓ | ✓ | |
| Data persistence across sessions | | | | ✓ |
| Unlimited seats | | | | ✓ |
***
## Builder Collaboration
Admin and Builder users can collaborate with each other by sharing a workflow. Sharing sends the selected user a copy of the workflow and its documents, which they can edit, run, and share on their own account.
Only Admins and Builders can send and receive workflow copies this way — Organizational Users and Users don't have this capability.
### Best practices for Builder Collaboration
Decide which Admin or Builder account will hold the official, most up-to-date version of each workflow. This is the account you'll pull links from to send to users and where you'll track responses in Data Manager.
Use **Send Copy to Builder** to let a colleague make edits. Select the recipient(s) and click **Send a Copy**.
Once the colleague finishes editing, they use **Send Copy to Builder** to send the updated workflow back to the original Builder. The colleague keeps their own version of the edited workflow too.
Back on the original account, the Builder chooses how to bring in the update:
* **Overwrite** — replaces the prior version and keeps all existing links pointing to that workflow.
* **Add as a new file** — brings the edit in as a separate copy, useful for reviewing changes before committing. Once reviewed, rename it to match the original to overwrite the prior version.
***
## Inviting and managing users
All user management is handled from the **Users** page, accessible from the main navigation. Only Admins can invite new users or change existing users' roles.
Click **Users** in the left-hand navigation of your Dashboard.
Click **Invite User** (or the equivalent button on your plan). Enter the person's email address and select their role — Admin, Builder, Organizational User, or User. Gavel sends them an invitation email with a link to set up their account.
Find the user in the list. Click their row or the edit icon to change their name, email address, or role. Role changes take effect immediately.
To remove someone's access, deactivate their account from the Users page. Their historical data is retained, but they can no longer sign in.
When a client follows a login-required workflow link and creates their own account, they are automatically added to your Users page with the **User** role. You don't need to manually invite them first.
***
## Where each role lands after sign-in
Taken to the full **Dashboard** with access to workflows, bundles, data, and settings.
Taken to their **portal** (`yoursubdomain.gavel.io/portal`) where they see their assigned workflows and bundles.
Taken to their **client portal** where they see only the workflows assigned to them and their saved responses.
Prompted to create an account, then directed to the specific workflow they clicked — or to their portal if accessing a login-required page directly.
# What can you automate with Gavel workflows?
Source: https://helpdocs.gavel.io/workflows/what-can-you-build
Explore the full range of use cases for Gavel document automation: internal drafting, client intake, client portals, decision trees, and paid workflows.
Gavel is designed to serve legal professionals across a wide range of practice settings and workflow types. Whether you want to speed up internal drafting, build a self-service tool for clients, or create a revenue-generating legal product, the same core platform supports all of it. The difference lies in how you configure access and what you connect as output.
The sections below describe the main categories of workflows you can build, with examples drawn from common legal practice areas.
***
## Use cases
Use Gavel within your organization to generate documents more efficiently. You and your colleagues complete the questionnaire, and Gavel produces a polished document instantly. This works especially well for high-volume, repetitive document types — demand letters, engagement letters, closing checklists, or standard contracts — where the facts change but the structure stays the same.
**Examples:** NDA generator for your deal team, employment offer letter tool, standard lease generator for a property management practice.
Set up a workflow where a client fills out the questionnaire to provide their information, and you generate the documents in-house after reviewing the data. The client never sees the final document unless you share it with them — they just answer questions, and the information flows into your document automatically.
**Examples:** Estate planning intake, personal injury intake, immigration questionnaire, corporate formation intake.
Publish workflows publicly or behind a login so clients can access and complete them directly, receiving generated documents on the output page without your involvement. This is the basis of a self-service legal portal.
**Examples:** Simple will generator, tenant's rights letter tool, small claims demand letter, business formation wizard.
Build logic-driven workflows that guide users through a decision tree rather than (or in addition to) producing documents. Use conditional logic and **Kickout Pages** to route users to different outcomes based on their answers — for example, telling an ineligible applicant they do not qualify, or directing a user to one of several document paths based on their situation.
**Examples:** Benefit eligibility screener, jurisdiction selector, legal needs triage tool, intake qualification filter.
Integrate Stripe into a workflow (or group of workflows) to collect payment before documents are generated. This lets you monetize automated documents as standalone products or as part of a subscription-based client portal.
**Examples:** Paid will package, pay-per-document contract generator, subscription-based lease drafting tool.
***
## Choosing the right approach
The structure of a workflow is the same regardless of use case. What changes is who fills it out and how you configure access and output. Here is a quick guide to help you decide:
| Goal | Configuration |
| ------------------------------------------ | -------------------------------------------------------------------------------------- |
| Internal team use only | Restrict access to specific team members, or restrict based on email domain |
| Gather client data, generate docs yourself | Multi-user workflow; client completes questionnaire, you generate docs |
| Let clients self-serve | Publish publicly or via direct link; client receives output docs directly |
| Decision tree | Use Kickout Pages and conditional logic; output docs optional |
| Charge for document access | Add Stripe payment requirement at the start of questionnaire or before the output page |
Start with a simple internal workflow to get comfortable with the process. Once you understand how questions map to document variables, you can quickly adapt the same workflow for client-facing use.
Gavel provides the tools to create workflows, or questionnaires, that gather data you can use to automate documents and so much more! There are many ways to set up a workflow. You can set up workflows that are internal only, client-facing, or a combination of both. From there, you can use [Data Manager](/workflows/data-manager) to push answers from one workflow to another workflow. This will eliminate the need to reenter information and reuse client data across many workflows.
Read on for tips on using Gavel to build your estate planning workflow and automate your documents.
***
## Examples and inspiration
Gavel publishes case studies and real-world examples from legal professionals using the platform.
* View **case studies** at [gavel.io/category/case-studies](https://www.gavel.io/category/case-studies)
***
## Ready to build?
Follow the step-by-step guide to build and test your first workflow.
See all available question types and when to use each one.
# Submit a Feature Request for Gavel Workflows
Source: https://helpdocs.gavel.io/workflows/wishlist
Submit feature requests and suggestions to help shape the future of Gavel Workflows — the team reviews every idea and uses your feedback to guide development.
Your feedback shapes what Gavel Workflows builds next. If there is a feature you wish existed, a workflow you want improved, or an idea that would make Gavel more useful for your practice, submit it on the wishlist. The Gavel Workflows team reviews every suggestion.
Visit the Gavel Workflows Wishlist to share your ideas, vote on suggestions from other users, and track what the team is working on.
## Explore or get help
Reach the Gavel Workflows team by email, phone, or scheduled call for immediate help.
See what Gavel Workflows can do and learn how to get the most out of the platform.
# Gavel Document Tagger
Source: https://helpdocs.gavel.io/workflows/word-documents
Upload your file to Gavel, install the Word add-in, tag variables in your .docx template, and troubleshoot common spacing and tag issues.
Word documents are the most common template type in Gavel. You prepare a standard `.docx` file and upload the file to your workflow. Mark the places where questionnaire answers should appear using the Document Tagger Word add-in. When a user completes the questionnaire, Gavel replaces every tag with the corresponding answer and generates a finished document — either as a Word file, a PDF, or both.
## Upload your template to Gavel
You can upload it to Gavel in three ways:
* **Gavel Blueprint** — the AI-enabled workflow builder. Click **New Workflow > Start with documents**, upload your `.docx` file, and Blueprint automatically reads your document, identifies variables, and generates a draft questionnaire for your review.
* **Document Templates tab of a workflow** — open any existing workflow, go to the **Document Templates** tab, and upload the file directly.
* **Document Templates section of the dashboard** — upload templates centrally and attach them to workflows later.
If you have already uploaded the template to a workflow, you can update it directly from the Word add-in: select the document name in the add-in's dropdown and click **Update Document**. This saves you from re-uploading manually.
## Install the Gavel Word add-in
Gavel provides a no-code Word add-in called **Document Tagger** that lets you insert and manage all variable tags without writing syntax by hand. The add-in is available in the Microsoft Office Add-ins store.
Open Microsoft Word and go to the Office Add-ins store. Search for **Gavel** or visit the store page directly. Once installed, click **Document Tagger** in the Word Ribbon to open the panel.
In your Gavel account, go to **Settings > API Keys**. Enter a title for the key and click **Create a Key**. Copy the key immediately — Gavel does not display the same key twice for security reasons. Keep the key somewhere safe in case you need it again.
![API Key Image]()
In the Document Tagger panel, enter your **Client Name** (your Gavel subdomain) and paste the API key you just copied. Click **Login**.
Once logged in, choose the workflow you are building or editing from the dropdown. The add-in loads all the variables already defined in that workflow, so you can insert them by clicking rather than typing.
You can upload your output document to the workflow's Document Templates tab before using the add-in.
If you add new questions to your workflow later, click the refresh arrow in the add-in to pull in the updated variable list.
## What you can tag with the add-in
The Document Tagger add-in covers the full range of tagging tasks without requiring you to write syntax manually.
Insert any workflow variable and optionally apply formatting — uppercase, first-letter capitalised, or various date formats. The `{{ today() }}` function is also available for inserting the current date.
Format number variables as currency, percentages, or custom numeric formats directly from the add-in panel. For formats not listed, you can use advanced syntax from the Code Curious section of the Learning Center.
For multi-select question types, the add-in inserts only the selected values as a list. You can choose comma-separated, Oxford comma, semicolon, or a custom separator.
Highlight any text in your document and set the conditions under which it should appear. **Show Phrase when** hides just the highlighted text. **Show Paragraph when** removes the entire paragraph and its line, and renumbers any surrounding numbered lists automatically.
Build calculations using addition, subtraction, multiplication, and division across number variables. For date calculations, you can find the time between two dates or add/subtract days, weeks, or years from a date variable or from today's date.
Tag repeating item data in four formats: comma lists (single line), multi-line paragraphs, auto-generated Word tables, or generate-multiple (one document per repeating item instance). You can also create conditions based on the number of repeating item instances or the value of a specific attribute.
## Variable tag syntax
Every variable in your Word template is wrapped in double curly brackets with a space on each side:
```text theme={null}
{{ variable_name }}
```
Variable names are **case-sensitive** and must match the variable names in your Gavel workflow exactly. Here is a short example showing variables placed in a letter template:
```text theme={null}
Dear {{ FirstName }},
This agreement is dated {{ AgreementDate }}.
Signed,
{{ LawyerName }}
```
When the workflow runs, Gavel substitutes each tag with the answer the user provided. You can apply any Word text formatting — bold, italic, underline — directly to the tag, including the curly brackets. The formatting carries through to the generated document.
Variable names in Gavel are case-sensitive. `{{ clientname }}` and `{{ ClientName }}` are treated as two different variables. Always verify that the variable name in your template matches the variable name in your workflow questionnaire.
## Auto-adjusting custom numbering
If your document uses section numbers written as plain text (not as Word list fields), they will not renumber automatically when a paragraph is removed by conditional logic. Gavel's **Number Iterator** functions solve this by inserting counters that renumber at runtime.
| Function | Output format |
| --------------------------------- | -------------------------------- |
| `{{ number_iterator() }}` | Written number (one, two, three) |
| `{{ number_iterator_ordinal() }}` | Ordinal (first, second, third) |
| `{{ number_iterator_numeric() }}` | Numeric (1, 2, 3) |
| `{{ number_iterator_roman() }}` | Roman numeral (I, II, III) |
For example, if you have three sections and the second is removed by conditional logic, the third section automatically becomes Section Two:
```text theme={null}
Section {{ number_iterator() }}
Some text here.
Section {{ number_iterator() }}
Some text here.
Section {{ number_iterator() }}
Some text here.
```
Be sure your Word document uses **List Styles** for any outlines or numbered articles that you plan to make conditional. This allows the output document to update numbering formats automatically when conditions are met or not met.
## Templates within templates
For advanced use cases, you can embed the full content of one `.docx` file inside another using the include syntax:
```text theme={null}
{{p include_docx_template('sub_document_name.docx') }}
```
Place this tag in your main document at the location where the subdocument's content should appear. Both the main document and the subdocument must be `.docx` files. The subdocument name must use underscores instead of spaces and include the `.docx` extension, written exactly as the file is named.
This is useful for shared headers that change frequently, or standard clauses (such as non-compete language) that appear in multiple documents. You update the subdocument once and every main document that references it reflects the change automatically.
Templates-within-templates should only be used when standard conditional logic cannot achieve the same result. In most cases, regular Show Phrase / Show Paragraph conditions are sufficient.
## Troubleshooting
Conditional logic affects line spacing depending on which type of condition you use:
* **Show Phrase when** — removes only the text inside the condition. The line itself and its surrounding spacing remain, which can leave an empty line if an entire paragraph is hidden this way.
* **Show Paragraph when** — removes the entire paragraph, the line it occupied, and any surrounding blank lines. Numbered lists renumber automatically.
Use **Show Phrase when** for a few words or a short sentence inline. Use **Show Paragraph when** whenever you want to conditionally remove an entire paragraph, a bulleted list item, or a full page.
If your generated document shows raw tags instead of values, check the following:
* Have you accidentally deleted a curly bracket? Each tag requires two opening `{{` and two closing `}}` brackets.
* Are variable names spelled correctly and in the right case? Gavel variable names are case-sensitive and must match your workflow exactly.
* Does every `if` condition have a matching `endif` closing tag?
* Do the opening and closing tags for conditions match? If your `if` tag includes a `p` (for paragraph), the `endif` must as well.
Use the **Check for Errors** button in the Document Tagger add-in to scan your document for syntax problems before running the workflow.
# Gavel to Zapier
Source: https://helpdocs.gavel.io/workflows/zapier-webhooks
Send Gavel workflow answers and documents to thousands of apps via Zapier, or post data to any URL using Gavel's built-in custom webhook settings.
When a user completes a Gavel workflow, you can automatically push their answers — and the generated documents — to any other system you use. Gavel connects to Zapier through a native app with a "Workflow Completed" trigger, and also supports raw webhook URLs for custom integrations. Whether you want to create a matter in your practice management system, add a row to a spreadsheet, or send a Slack notification, the setup takes only a few minutes on each side.
## What is Zapier?
Zapier is a no-code automation platform that connects web applications. Each automated workflow in Zapier is called a "Zap." A Zap starts with a **trigger** — an event in one app — and runs one or more **actions** in other apps. Gavel acts as a trigger: when a user finishes a Gavel workflow, the Zap fires and carries the answers into whatever apps you configure.
Gavel's Zapier app uses the trigger event **"Workflow Completed."** You map this to any Zapier action — creating contacts, updating spreadsheets, sending emails, and more.
***
## Send data from Gavel to Zapier (data only)
Use this path when you want to send questionnaire answers to another app but do not need to include the generated documents.
Zapier expects consistent field names. Complete and test your workflow before connecting it to Zapier. If you later add, remove, or rename questions, you will need to update your Zap to match.
Log in to Zapier and click **Create Zap**. In the trigger search box, type **Gavel** and select it from the results.
In the **Trigger Event** dropdown, choose **Workflow Completed**, then click **Continue**.
Zapier will prompt you to authenticate. Enter your Gavel **subdomain** and your **API key**. If you have not created an API key yet, see [Creating an API key](/workflows/api#creating-an-api-key).
In your Gavel workflow, open **Settings > Integrations** and click **Send Test Data**. This sends a sample payload to Zapier so it knows what fields to expect.
Back in Zapier, click **Test trigger**. You will see a list of all the variable names and values sent from Gavel. Click **Continue** to proceed to the action step.
Select the app you want to send data to and map Gavel's fields to that app's fields. Click **Publish Zap** when you are ready.
Zapier adjusts variable names slightly for display: underscores are removed and the name is title-cased. A Gavel variable named `my_address` appears in Zapier as **My Address**. The underlying data is unchanged.
***
## Send data and documents from Gavel to Zapier
When you also want your generated documents delivered through Zapier, use the **Webhooks by Zapier** approach instead of the native Gavel trigger.
As with the data-only path, complete and test the workflow before wiring up Zapier.
In Zapier, click **My Apps**, search for **Gavel**, and authenticate with your subdomain and API key.
Click **Create Zap**. In the trigger search box, type **Webhooks by Zapier** and select it.
In the **Trigger Event** dropdown, choose **Catch Hook**, then click **Continue**. Zapier will generate a webhook URL — copy it.
Open your workflow in Gavel, go to **Settings > Integrations**, and paste the webhook URL. Check the **Include Documents** checkbox to attach your generated documents to the payload.
Click **Send Test Data** in Gavel to fire a test payload to the Zapier webhook URL.
In Zapier, click **Test trigger**. Confirm you can see the Gavel variable data (and document URLs if you enabled Include Documents). Click **Continue**.
Map the Gavel fields to your target app's fields and publish the Zap.
***
## Custom webhooks (non-Zapier integrations)
If you have a developer or prefer to build your own integration, you can send workflow data to any HTTP endpoint directly from Gavel — no Zapier required.
In the workflow builder, go to **Settings > Integrations** and click **New Webhook**.
Paste your endpoint URL into the **Webhook URL** field.
Check the **Include Documents** checkbox if you want the generated output documents to be included in the payload.
If your endpoint requires authentication or custom headers, expand the headers section and add the key-value pairs you need.
Click **Send Test Data** to fire a test payload. Use a tool like [requestbin.com](https://requestbin.com) or [postb.in](https://postb.in) to inspect the shape of the request before you go live.
***
## Question types Gavel sends to Zapier
Gavel sends answers for the following question types through both the Zapier app and webhook:
Text, Text Area, Dropdown, Combobox, Single Select, Multi Select, Yes/No, Number, Number (with decimal), Date, Email, Repeating Item (with all supported sub-types), Clio Contact, Clio Matter, CSV Data Source, and any variables created via Invisible Logic.
***
## Advanced Zapier features
Once your data is flowing into Zapier, you can use Zapier's built-in tools to build sophisticated automations:
Use Paths to send data down different branches depending on the answers in your workflow. For example, route new estate planning clients to one action and business clients to another based on a question answer.
Add a Filter step to stop a Zap from running unless specific criteria are true. For example, only create a new matter in your practice management system if the client answered "Yes" to a specific question.
Use Formatter to reformat dates, change text case, split names into first and last, extract phone numbers, or perform calculations on numeric answers before sending them to the next app.
Use Zapier's Looper app to run subsequent steps once for each row in a Gavel repeating item — for example, creating one calendar event per party in a multi-party agreement.
Add a Delay step to hold an action for a set amount of time — for instance, send a follow-up email three days after a client completes an intake workflow.
If you cannot find a suitable app in the Zapier library, use the generic **Webhooks by Zapier** action to POST data to any custom endpoint your developer builds.