Insert variables

Using and inserting variables

To use variables in Tallyfy, click the button in any step title or description and select data from earlier form fields - that’s it. Variables automatically transfer information from one step to another within your process.

Here’s what makes variables powerful: they turn generic workflows into personalized ones. When someone fills out a form field in step 1, you can display that exact information in steps 5, 10, or 20 - without anyone retyping it. Think of variables as smart placeholders that remember what was entered earlier.

Requirements for using variables

• A template open in edit mode
• At least one form field in an earlier step (that’s your data source)
• A later step where you want to display that data

How variables work

Variables connect your workflow steps like invisible threads. Simple concept:

• Source: The form field where someone types information
• Target: Any step title or description where you want that info to appear
• Format: Variables appear as {{fieldName}} in curly brackets

When someone fills in the source form field, that exact value pops up wherever you’ve placed the variable. No copying, no pasting - it just appears. Change the source? The variable updates everywhere instantly.

Using variables for guest assignment

Common use case: Capture a guest email in the kick-off form, then use {{guestEmail}} in later step assignments. This lets you dynamically assign tasks to external people based on who’s specified at process launch.

Example: Kick-off form asks “Client email?” → Later step assigns task to {{clientEmail}} → That specific client gets the task automatically.

Important: Variables populate the assignee field but don’t automatically trigger assignment. You must create an automation rule that checks when the kick-off form is complete, then assigns the task to the email captured in the variable.

Types of variables you can insert

When you click the (Insert Variable) button, you’ll see three types of data to choose from:

• Kick-off form fields: Info entered when someone first launches the process

• Form fields from previous steps: Any data entered in steps that come before where you are now

• System variables: Tallyfy’s own tracking info like:

  • Current TaskID: The unique ID for this specific task
  • Current ProcessID: The unique ID for this process run
  • (You might see other system IDs too)

  Most users stick to form fields. System variables? They’re mainly for technical integrations¹ - like when you need to include an ID in a webhook or API call.

Benefits of using variables

Why use variables? Here’s what you gain:

• Consistency: That client name entered in step 1? It appears perfectly spelled in steps 3, 7, and 15. No typos.
• Live Updates: Change the source data, and watch it update everywhere. Instantly.
• Personalization: Instead of “Review proposal,” your team sees “Review proposal for Acme Corp” - much clearer
• Fewer Errors: Nobody’s copying and pasting (and inevitably making mistakes)
• Context: Important details stay visible throughout the entire workflow

Adding variables to step titles

1. Open your template in Edit mode.
2. 
3. Make sure you have a form field in an earlier step to get the data you want to display.
4. 
5. Go to a step that happens after the step with the form field.
6. Click on the step title to edit it.
7. Place your cursor where you want the variable information to appear.
8. Click the (Insert Variable) button that appears near the title field.
9. Select the form field (the source) from the list.
10. The variable (like {{fieldName}}) will be inserted. Save your changes if needed.

Adding variables to step descriptions

1. Open your template in Edit mode.
2. Ensure the source form field exists in an earlier step.
3. Go to a later step and click into its description box.
4. Place your cursor where you want the variable information to appear.
5. Click the (Insert Variable) button in the text editor toolbar.
6. Select the form field (the source) from the list. 7.Inserting variables in description ↗
7. The variable will be inserted. Changes save automatically.

How variables work during process execution

Here’s what happens when your process runs:

1. Someone fills out a form field in an early step
2. Tallyfy stores that value (don’t worry - it’s secure)
3. Later steps with variables automatically show the actual values instead of placeholders like {{fieldName}}
4. Need to fix a typo? Update the source field and watch the change ripple through

It’s that straightforward. No magic, just smart data flow.

Common variable examples

Making task titles specific

• “Get approval for Project: {{projectName}}”
• “Review document for Client: {{clientName}}”
• “Schedule meeting with {{departmentName}} lead”

Making instructions specific

• “Please review the proposal for {{clientName}}, focusing on the section about {{focusArea}}.”
• “Call {{customerName}} at {{phoneNumber}} to discuss their order {{orderNumber}}.”
• “Prepare the {{documentType}} based on the request from {{requestingDepartment}}.”
• “Upload your documents here: {{fileRequestLink}}” (useful for file request links from your DMS)

Renaming projects with field values

Variables shine when combined with auto-naming. Your processes can name themselves based on the data entered:

• “Onboarding - {{employeeName}} - {{department}}”
• “Support Ticket - {{ticketNumber}} - {{clientName}}”
• “Project Setup - {{projectName}} - {{priority}}”

Result? Every process gets a meaningful name automatically. No more “Process #12345” confusion.

Tips for effective variable usage

Want variables that actually work? Follow these practices:

• Name your form fields clearly. “Customer Name” beats “Field 1” every time
• Always test-run your template. Trust me on this one.
• Consider empty fields - if someone skips the “Department” field, will “Contact the lead” still make sense?
• Use variables for anything that changes between process runs (names, dates, amounts)
• Surround variables with context: “Contact {{name}} at {{phone}}” not just “{{name}} {{phone}}”

Advanced variable techniques for dynamic content substitution

Ready to level up? Here’s where variables get really interesting.

Creating adaptive instructions: One template can handle multiple scenarios. No more maintaining 10 slightly different versions of the same process.

Example - Purchase requisition that adapts to amount: Your kick-off form asks for “Purchase Amount”. Then magic happens:

• Step title becomes: “Get approval from {{approverTitle}}”
• Automation rules set {{approverTitle}} based on the amount:
  • Under $1,000: “Department Manager”
  • $1,000-$10,000: “Division Director”
  • Over $10,000: “CFO”

Building personalized checklists: Watch how variables combine with conditional visibility:

1. Kick-off form asks: “Which region?” (dropdown: North, South, East, West)
2. Instructions say: “Complete the {{region}} region compliance checklist”
3. Conditional rules show only that region’s requirements
4. One template now does the job of four. Nice.

Dynamic email notifications: Your automated emails can speak directly to each recipient:

• Subject: “Action required: {{taskName}} for {{clientName}}”
• Body: “The {{documentType}} for {{projectName}} needs your review by {{dueDate}}”

Real emails, real names, real deadlines. Much better than “You have a task waiting.”

Variables + Conditional Logic = Smart Templates

The real power comes from combining variables with conditional automations. This lets you create intelligent templates that adapt based on the data entered, eliminating the need for multiple similar templates.

Troubleshooting broken variables

Variables showing as raw text instead of values? (like seeing {{clientName}} instead of “Acme Corp”)

This happens when variables lose their connection to the source field. The fix is simple:

1. Delete the broken variable text completely
2. Click the (Insert Variable) button again
3. Re-select the field from the dropdown
4. Save your changes

Common causes of broken variables:

• Renaming or deleting the source form field
• Copying template content from another template
• Manual typing of variable syntax instead of using the insert button
• Template import/export operations that disconnect references

Pro tip: Always use the button to insert variables rather than typing them manually. This ensures proper field linking.

Variables in URLs - Hidden character issue

URLs with variables may contain hidden characters

When embedding variables in URLs within step descriptions, the editor may insert invisible UTF-8 BOM characters² (%EF%BB%BF) that break the links.

Problem: Your URL shows as https://example.com?id=%EF%BB%BFvalue%EF%BB%BF instead of https://example.com?id=value

Solution - Compose URLs externally:

1. Build your complete URL in a plain text editor first
2. Include the variable placeholders: https://example.com?id={{recordID}}
3. Copy the entire URL from your text editor
4. Paste it into the step description as a complete unit
5. Test the link in a launched process to verify it works

Why this happens: The rich text editor adds invisible formatting characters around inserted variables. Composing the URL externally avoids this issue.

Related articles

Templates > Variables

Variables are placeholders that automatically transfer information from one process step to another eliminating manual data re-entry and enabling personalized automated workflows through form field data collection and dynamic content insertion.

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.

Tutorials > Create an automation

Tallyfy automates processes through intelligent if-this-then-that conditional logic that dynamically adapts workflows based on specific conditions like form field values task completions and approval decisions eliminating manual adjustments and reducing administrative overhead.

Footnotes

1. System IDs use 32-character hash format for all primary entities in Tallyfy’s PostgreSQL database ↩

2. Byte Order Mark characters (U+FEFF) used for encoding detection but can corrupt URL parameters ↩