Variables

Understanding variables

Variables in Tallyfy work like smart placeholders - they grab information from one step in your process and automatically show it wherever else you need it. No more copying and pasting the same data over and over.

Variables = Mail Carriers or Sticky Notes

Here’s the easiest way to think about variables:

• Mail Carrier: Let’s say someone types in a Customer Name at the beginning of a Tallyfy process. A variable is like a mail carrier who picks up that name and delivers it to every step that needs it - task titles, emails, wherever. The name just appears. Like magic.

• Sticky Note: Picture writing the Customer Name on a sticky note when the process starts. That note (your variable) travels along with the workflow, so everyone downstream sees the right name without having to ask for it again.

This automatic info-carrying saves tons of time and cuts out those annoying copy-paste errors.

Benefits of using variables

What can variables actually do for you?

• Pass data: Information someone enters in step 1 automatically appears in steps 5, 8, and 12.
• Show live info: Text updates instantly based on what users type in.
• Personalize: Your task instructions mention the actual client’s name, not just “the client.”
• Drive automation: Set up automation rules that react to variable values (if Customer Type = “VIP”, then route to senior staff).
• Keep consistent: That order number stays exactly the same everywhere it appears - no typos, no mix-ups.

How variables function

Here’s how the whole thing works:

1. Origin: Variables pull their data from form fields you’ve added to tasks. Simple as that.
2. Insert: When building your template, you drop a variable into a later step (it’ll look like {{fieldName}}[^1]). Just click the button to add one.
3. Fill: Someone completes the form field in an early step? Tallyfy remembers that value.
4. Display: When the process reaches your later step, boom - Tallyfy swaps out the placeholder with the actual value they entered.

It’s really that straightforward.

Variable sources

Where do variables come from? Any form field you add to your template steps:

• Text fields (quick answers or long paragraphs)
• Date fields
• Number fields (quantities, amounts, whatever)
• Dropdown menus, radio buttons, or checklists
• Fields where folks pick team members (Assignee Picker)

Got a form field? You’ve got a variable.

Common variable uses

Here’s where variables really shine:

• Client name appears in every relevant task title - no manual updating
• Project due date from step 2 shows up automatically in steps 10, 15, and 20
• Approval tasks reference the exact answers someone gave three steps ago
• Document templates fill themselves out with process-specific details
• Dropdown selections trigger different paths through your workflow (pick “Rush Order” and watch Tallyfy route it accordingly)

• Insert variables

Related articles

Variables > Insert variables

Variables in Tallyfy automatically transfer information from form fields in earlier steps to later step titles and descriptions by clicking the [ ] button and selecting the data source which eliminates retyping and personalizes workflows with dynamic content that updates instantly when source data changes.

Features > Fill in the blanks

Tallyfy enables users to replace document cloning with smart templates that combine unchangeable standard text with customizable fill-in-the-blank fields snippets for reusable content blocks and variables that automatically pull in previously collected data to streamline document creation and reduce errors.

Tasks > Set default content for form fields

Default content in Tallyfy form fields automatically pre-fills values when tasks or kick-off forms open saving time reducing errors and ensuring consistency across processes while supporting text fields selection fields and date fields through static text dynamic variables or system-generated values that users can still modify as needed.

Edit Processes > Auto-name a process in Tallyfy

Auto-naming processes creates consistent naming patterns from template variables to replace manual inconsistent naming that makes processes hard to find and track.