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”
Launch a separate process for each speaker
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:
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
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:
Can tasks be assigned to specific people for specific items?
Do you need to track individual item status?
Could one item’s delay block others unnecessarily?
Would parallel processing help?
If you answered “yes” to any of these, convert to unit-based design:
Document current bulk process
Identify the natural unit (invoice, employee, order)
Redesign for single unit with clear ownership
Test with one instance
Launch multiple instances via API or automation
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.
Tallyfy is purpose-built for repeating business work like onboarding and invoice processing where you launch proven templates in clicks instead of recreating project plans from scratch every time and it turns predictable operations into self-running workflows that improve with each use while project management tools should be reserved for truly unique one-time endeavors like building a bridge or launching a product.
Tallyfy templates are reusable process blueprints that you create once and launch repeatedly to assign tasks and track progress automatically while solving problems like inconsistent quality and lost knowledge through three types: procedure templates for multi-step workflows with conditional logic and document templates for reference materials and form templates for standalone data collection.
Tallyfy uses a single master template as the authoritative blueprint that spawns unlimited customized process instances — each with its own data and timeline — where template updates only affect future launches while running processes remain untouched and a continuous feedback loop drives ongoing improvement.
In Tallyfy a process is a live running instance of a template that you launch and track daily where each process captures a snapshot of its template at launch time and can be uniquely named or auto-named while allowing extra tasks to be added on the fly and then archived or restored after completion.
Footnotes
Tallyfy exports process analytics data (completion times, task durations) for analysis in external BI tools when analytics is enabled for your organization. ↩