---
title: Thinking in unit terms · Tallyfy Pro
description: Tallyfy templates should handle one item at a time, like one employee or one invoice, rather than batches. This creates clear task ownership, precise tracking, and lets you launch hundreds of parallel instances that each progress independently.
lastUpdated: 2026-06-13T00:00:00.000Z
source_url:
  html: https://tallyfy.com/products/pro/documenting/templates/thinking-in-unit-terms/
  md: https://tallyfy.com/products/pro/documenting/templates/thinking-in-unit-terms/index.md
---

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

## Design templates for one instance at a time

Build your Tallyfy templates to handle one item - one employee, one invoice, one customer. Not batches. This gives you clear task ownership, precise tracking, and the ability to run many instances in parallel.

Templates designed for single units scale naturally. Run them once or a thousand times.

## The bulk processing trap

You’ve probably seen workflows like these:

* “Process all invoices for the month”
* “Onboard the new hires starting Monday”
* “Review all contract renewals”

This bulk thinking creates real problems:

* **Unclear ownership** - who handles which specific invoice?
* **No individual tracking** - can’t see status of each item
* **All-or-nothing completion** - one delayed item blocks everything
* **Poor accountability** - “someone else probably did it”

Instead, design templates for single instances:

* “Process invoice #12345”
* “Onboard John Smith”
* “Review Acme Corp contract renewal”

You get clear ownership, precise tracking, parallel processing, and one owner per task.

## Example: Conference speaker management

**Wrong - bulk design**: “Manage all conference speakers”

* Task: “Collect bio from speakers” - who contacts which speaker?
* Task: “Arrange travel” - mixing 10 speakers’ flights in one task
* If one speaker delays, everything stalls

**Right - unit design**: “Onboard conference speaker”

1. Launch a separate process for each speaker

2. Each process tracks one speaker’s journey:

   * Collect bio from Jane Doe
   * Arrange Jane’s travel (conditional logic for local vs. remote)
   * Process Jane’s payment
   * Send Jane’s session details

Result - perfect visibility, clear ownership, parallel progress.

## How to convert bulk thinking to units

### Identify the true unit

Ask: “What’s the single thing we’re processing?”

* Not “employees” - one employee
* Not “orders” - one order
* Not “maintenance tasks” - one equipment item

### Name templates clearly

* Poor: “Monthly invoice processing”
* Good: “Process single invoice”
* Best: “Process invoice - Standard workflow”

### Design for one, launch for many

Your template handles one invoice. Need to process 100? Launch 100 separate processes. You can call the Tallyfy API repeatedly or use automation tools to launch multiple instances from a list.

### Use clear process names

When launching, use specific identifiers:

* “Invoice #2024-1234 - Acme Corp”
* “Onboard: Sarah Johnson - Marketing Manager”
* “Equipment Inspection: Crane #5 - Q1 2025”

## Common scenarios

### Employee onboarding

**Wrong**: “Onboard Q1 new hires” **Right**: “Onboard new employee” (launch per hire)

Each employee has different start dates, department requirements, equipment needs, and training schedules.

### Customer implementation

**Wrong**: “Implement all January customers” **Right**: “Implement customer account” (launch per customer)

Each customer has unique requirements, timelines, contacts, and success criteria.

### Document processing

**Wrong**: “Review all contracts” **Right**: “Review contract” (launch per contract)

Each contract needs a specific reviewer, individual negotiation tracking, separate approval chains, and its own deadline.

## Advanced patterns

### Conditional logic per unit

When you design for units, conditional logic works cleanly:

```plaintext
IF Speaker Location = "International" THEN
  - Add visa assistance task
  - Include customs forms
  - Extend timeline by 2 weeks
```

Each process adapts to its specific needs. No manual checking required.

### Parallel processing

With 20 employee onboarding processes running at once:

* HR handles background checks across all hires
* IT provisions equipment based on start dates
* Managers review their specific new hires

Everyone moves at their own pace. No waiting for the slowest item.

### Metrics and insights

Unit-based design gives you real data - average onboarding time, which steps take longest, and whether you’re hitting deadlines. Tallyfy exports analytics data for analysis in your BI tools.[1](#user-content-fn-1)

Bulk processes only tell you “completed or not.” That’s not useful.

## When bulk operations make sense

Some tasks within a unit process can be bulk:

* “Send welcome email to all attendees”
* “Generate monthly report of all processed invoices”
* “Archive completed contracts”

These work because they’re reporting or communication tasks. Nobody’s waiting on them to continue their work.

## Converting existing bulk processes

Ask yourself:

1. Can tasks be assigned to specific people for specific items?
2. Do you need to track individual item status?
3. Could one item’s delay block others unnecessarily?
4. Would parallel processing help?

If you answered “yes” to any of these, convert to unit-based design:

1. **Document current bulk process**
2. **Identify the natural unit** (invoice, employee, order)
3. **Redesign for single unit** with clear ownership
4. **Test with one instance**
5. **Launch multiple instances** via API or automation
6. **Track improvements** in clarity and speed

## Tips for unit-based templates

### Use form field variables

* `{{Employee Name}}`
* `{{Invoice Number}}`
* `{{Customer Company}}`

These variables (from kick-off form fields) make each instance clearly identifiable in process names.

### Design for the 80% case

Build for the standard scenario, then use conditions for exceptions. Don’t overcomplicate.

### Keep related units linked

Use task comments to reference related processes:

* “See also: Contract Review #123”
* “Parent project: Q1 Implementation”

### Run reports across instances

While each process is unit-based, you can still run reports across all instances and update the template for all future launches.

## Related articles

[**Miscellaneous > Tallyfy vs. Projects**](https://tallyfy.com/products/pro/miscellaneous/understanding-tallyfy-vs-project-management/)

Tallyfy handles repeating business work like onboarding and invoice processing. Launch proven…

[**Templates > Templates vs. processes**](https://tallyfy.com/products/pro/documenting/templates/master-templates-vs-processes/)

Tallyfy uses a single master template to spawn unlimited customized process instances, each with…

[**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…

## Footnotes

1. Tallyfy exports process analytics data (completion times, task durations) for analysis in external BI tools when analytics is enabled for your organization. [↩](#user-content-fnref-1)

## Was this helpful?