---
title: Templates vs. processes · Tallyfy Pro
description: Tallyfy uses a single master template to spawn unlimited customized process instances, each with its own data and timeline. Template updates only affect future launches while running processes stay untouched.
lastUpdated: 2026-09-03T00:00:00.000Z
source_url:
  html: https://tallyfy.com/products/pro/documenting/templates/master-templates-vs-processes/
  md: https://tallyfy.com/products/pro/documenting/templates/master-templates-vs-processes/index.md
---

[Full-seat members](https://tallyfy.com/products/pro/by-role/editor/)

## Single source of truth

![Blueprint master template launching into three customized building processes](https://screenshots.tallyfy.com/illustrations/templates-vs-processes.jpeg)

Templates in Tallyfy are your single source of truth - one authoritative version that generates customized processes. Update the template once, and future launches stay consistent. Running processes aren’t affected.

Think of it like a cookie cutter (template) and cookies (launched processes). Same shape - but each cookie gets different icing, sprinkles, or decorations.

## Template to process relationship

One master template spawns multiple customized processes while each stays version-independent.

![Template to Process Relationship](https://tallyfy.com/products/d2-diagrams/docs/pro/documenting/templates/master-templates-vs-processes-0.svg)

**Diagram description:** A single master template generates multiple customized process instances with a continuous improvement loop. Each process has unique customizations (Client A data, Client B timeline, Client C regional rules). Feedback from running processes flows back to improve the template for future launches.

**What to notice:**

* **One-to-many relationship** - A single template creates unlimited process instances, each customized for different clients or regions
* **Version independence** - Processes launched from v1 continue unchanged even after the template updates to v2[1](#user-content-fn-2) - in-flight work stays consistent
* **Continuous improvement** - Feedback from running processes improves future template versions without disrupting current ones

## Key distinctions

### Templates (blueprints)[2](#user-content-fn-1)

* **Purpose**: Define standard process structure and logic
* **Editing**: Only users with `checklist_edit` permission can modify
* **Content**: Placeholders, automations, and standard text
* **Versions**: Revision history for compliance
* **Location**: **Templates** section in Tallyfy

### Launched processes (active instances)

* **Purpose**: Execute actual work with real data
* **Editing**: Users fill in fields and complete tasks
* **Content**: Actual client names, dates, and specific information
* **Status**: Tracks progress through active workflow
* **Location**: **Tracker** section in Tallyfy

## How customization works

### At the template level

You control what users can and can’t change when they launch a process:

1. **Set field permissions** - mark fields as editable or read-only
2. **Define conditional paths** - pair each condition with what should happen next
3. **Set up automation** - configure assignments and deadlines
4. **Lock standard content** - protect compliance text and procedures

### At the process level

When someone launches a process from your template:

1. **Fill in specific data** - client names, project details, dates
2. **Activate conditional paths** - selections determine which tasks appear
3. **Edit allowed sections** - change fields marked as editable
4. **Own timeline** - each process tracks its own deadlines

## Real-world example

**Challenge**: CBRE manages hundreds of playbooks with multiple variations - agency vs. principal delivery models, different service types, and regional requirements across North America, Europe, and Asia.

**Without Tallyfy**: 100+ PowerPoint files with slight variations, manual updates when standards change, version control chaos with local copies, and no way to filter content dynamically.

**With Tallyfy**: One template with all variations, dynamic filtering based on user selections, instant updates when standards change, and each launched process shows only relevant content.

## Templates vs. document-based systems

| Traditional documents | Tallyfy templates |
| - | - |
| 100 copies of same SOP | 1 master template |
| Manual version tracking | Automatic versioning |
| Update each copy separately | Update template once |
| Static content for all | Dynamic, filtered content |
| Lost customizations in updates | Preserved instance data |
| Email chains for status | Real-time progress tracking |
| Scattered feedback | Centralized comments |

## Common misconceptions

### ”Can I edit the template while a process is running?”

Yes. Changes only affect future launches. Running processes continue with the version they started with.

### ”If I update a template, will running processes break?”

No. Running processes keep their original structure. In-flight work stays safe.

Template changes don’t affect running processes

**Processes are snapshots taken at launch time.** Tallyfy creates an independent copy with the template’s structure at that moment. Adding tasks, changing steps, or modifying the template afterward won’t change already-running processes. To apply template updates, launch a new process.

### ”Can different teams have different versions?”

Use conditional logic instead of separate versions. One template shows different content based on team, region, or other criteria.

### ”How do I manage 12+ variations?”

Don’t create 12 separate templates. Use conditional visibility and dynamic fields. One smart template replaces dozens of static documents.

## Best practices

### 1. Design for reusability

* Identify common elements across all variations
* Use [snippets](https://tallyfy.com/products/pro/documenting/templates/snippets/) for repeated content
* Build in flexibility with [variables](https://tallyfy.com/products/pro/documenting/templates/variables/)

### 2. Plan your customization strategy

* Decide what users can change vs. what stays locked
* Use form fields to capture variation needs
* Set up automations for different paths

### 3. Test before rollout

* Launch test processes for each major variation
* Verify conditional logic works correctly
* Gather feedback from pilot users

### 4. Maintain the template

* Review the template regularly
* Update based on process feedback
* Document major version changes

## Migrating from documents to Tallyfy

1. **Identify commonalities** - find shared content across all versions
2. **Map variations** - document what makes each version different
3. **Build smart** - create one template with conditional logic
4. **Import content** - use AI import to convert your best version
5. **Add automation** - layer in conditions and actions
6. **Test thoroughly** - verify all paths work correctly
7. **Train teams** - focus on the “why” of single-source benefits

## Related articles

[**Documenting > Templates**](https://tallyfy.com/products/pro/documenting/templates/)

Tallyfy templates are reusable blueprints you create once and launch repeatedly. They assign…

[**Tracking And Tasks > Processes**](https://tallyfy.com/products/pro/tracking-and-tasks/processes/)

A process is a live, running instance of a template that you launch and track daily. Each…

[**Pro > Launching**](https://tallyfy.com/products/pro/launching/)

Tallyfy lets you launch reusable templates into independent trackable processes, each with its…

[**Pro > Essentials**](https://tallyfy.com/products/pro/documenting/)

Tallyfy offers three template types. Procedure Templates for tracked workflows with automation…

## Footnotes

1. Uses `timeline_id` and `blueprint_timeline` fields to maintain process isolation from template changes [↩](#user-content-fnref-2)

2. Called ‘blueprints’ (or ‘checklists’) in Tallyfy API endpoints - this technical term maps to user-facing ‘templates’ [↩](#user-content-fnref-1)

## Was this helpful?