Editor-based contract templates are flexible, customizable templates built using GetAccept’s Editor. They allow teams to design contract content directly inside the platform using editable blocks, merge tags, pricing tables, conditional content, and interactive fields. These templates provide the highest level of adaptability and are ideal for contracts that need personalization, negotiation, or frequent iteration.
This article explains how Editor-based templates are structured, which elements they support, and how they behave throughout the contract workflow.
1. What Editor-based Templates Are Used For
Editor templates are designed for documents that require rich content and dynamic configuration. They are best used when:
Contracts need to be personalized for each deal
Content layouts change frequently
Pricing or product information varies by customer
Teams want flexibility to update text during negotiations
Legal language is standardized but editable
CRM data needs to flow directly into the contract
Common use cases include proposals, renewal agreements, MSAs, SoWs, onboarding documents, and multi-section commercial contracts.
2. Supported Content Elements
Editor templates use the full suite of Editor components, allowing teams to build visually structured, interactive contract content.
Content Blocks
Text and headings
Images and embedded media
Layout sections and columns
Tables and dividers
Resource embeds (links, files, videos)
Interactive Fields
These are fields that recipients complete inside the contract:
Text fields
Dropdowns
Checkboxes
Email and date fields
Signature fields
Merge fields
Conditional blocks
All interactive fields can be assigned to specific template roles, enforcing who fills in what.
3. Template Roles & Recipient Logic
Editor-based templates use predefined template roles to ensure consistent workflows.
Roles can include:
Signer
Approver (internal or external)
Viewer
Roles define:
Who must sign
Who reviews before signing
What fields each role must complete
Which sections appear for each role
What verification or signing methods apply
When a user creates a document from the template, they simply map real people to these roles, eliminating setup errors.
4. Merge Fields & Personalization
Editor templates support personalization using merge tags. Data can be pulled from:
The sender
Entity settings
Recipients
Custom variables
CRM fields (Salesforce, HubSpot, Dynamics, Pipedrive, etc.)
Merge fields allow teams to automate:
Company names
Contact information
Values and metadata
Product and pricing details
Dates and reference numbers
This reduces manual editing and ensures accuracy across all contracts.
5. Pricing Tables in Editor Templates
Editor templates can include pricing tables with:
Line items
Discounts
Taxes
Totals and summaries
Product descriptions
Pricing can be:
Pre-built and fixed in the template
Dynamically synced from CRM line items
Manually edited in the document before sending
This ensures consistent pricing formats across Sales and CS.
6. Conditional Content
Editor templates support content that appears only when certain conditions are met.
Conditions can be based on:
Recipient role
Dropdown or field values
CRM-driven logic (advanced plans)
Examples:
Show addendums only when certain products are selected
Hide internal instructions from customers
Display onboarding requirements based on contract tier
Conditional content keeps templates flexible while maintaining a single version of truth.
7. Behavior After Sending the Document
Editor-based templates allow controlled editing even after the contract is sent.
Non-signable documents
All content blocks remain fully editable
New blocks can be added at any time
Signable documents
Content inside existing blocks can be edited
Blocks cannot be added or removed after sending
Changes must be published before recipients see updates
Recipients receive an update notification
This supports real-time negotiation without needing to generate a new version unless the structure must change.
8. When to Choose Editor Templates Over PDF Templates
Use Editor-based templates when you need:
Flexible layouts
Dynamic personalization
Pricing automation
Negotiation-friendly workflows
Conditional logic
Rich, branded content
PDF templates are better when the layout must be locked or regulated.
Summary
Editor-based contract templates provide:
Full design flexibility
Automated personalization with merge tags
Structured roles and workflows
Interactive fields and validation
Pricing table capabilities
Conditional content logic
Post-send editing for negotiation
They offer the most powerful and scalable way to manage contract content inside GetAccept.