Skip to content

Thinking in unit terms

What does thinking in unit terms mean for workflow design?

Design your Tallyfy templates to handle one instance at a time - one employee, one invoice, one customer - not multiple items in bulk. This fundamental principle ensures clear task ownership, proper tracking, and workflow flexibility.

Here’s the thing: when you think in unit terms, you create templates that scale perfectly. Run them once or a thousand times - they just work.

Why unit-based design creates better workflows

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”

Sounds efficient, right? Wrong. This bulk thinking creates serious 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”

The unit-based solution

Instead, design templates for single instances:

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

The benefits? Immediate:

  • Clear ownership - John owns the Acme renewal task
  • Precise tracking - See exactly where each instance stands
  • Parallel processing - Run 50 instances simultaneously
  • Perfect accountability - Every task has one owner

Real-world example: Conference speaker management

Wrong approach: Bulk design

Template name: “Manage all conference speakers”

Watch what happens with this approach:

  • Task: “Collect bio from speakers” - But who contacts which speaker?
  • Task: “Arrange travel” - You’re mixing 10 speakers’ flights in one task
  • Task: “Process payments” - No visibility on individual speaker status
  • If one speaker delays, the entire process stalls

Messy.

Right approach: Unit design

Template name: “Onboard conference speaker”

Here’s how it actually works:

  1. Launch a separate process for each speaker
  2. Each process tracks one speaker’s complete journey:
    • Collect bio from Jane Doe
    • Arrange Jane’s travel (local vs. remote logic applies)
    • Process Jane’s payment
    • Send Jane’s session details

Result: Perfect visibility, clear ownership, parallel processing. That’s more like it.

How to convert bulk thinking to unit terms

Step 1: Identify the true unit

Start with this question: “What’s the single thing we’re processing?”

  • Not “employees” → One employee
  • Not “orders” → One order
  • Not “maintenance tasks” → One equipment item

Step 2: Name templates clearly

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

Step 3: Design for one, launch for many

Your template handles one invoice. Need to process 100 invoices? Simple - launch 100 processes. Tallyfy’s bulk launch features1 make this effortless.

Step 4: Use clear process names

When you’re launching, use specific identifiers:

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

Common scenarios requiring unit thinking

Employee onboarding

Wrong: “Onboard Q1 new hires” Right: “Onboard new employee” (launch for each hire)

Makes sense when you think about it - each employee has different:

  • Start dates
  • Department requirements
  • Equipment needs
  • Training schedules

Customer implementation

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

Why? Each customer brings unique:

  • Requirements
  • Timelines
  • Contact persons
  • Success criteria

Document processing

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

Each contract needs:

  • Specific reviewer based on type
  • Individual negotiation tracking
  • Separate approval chains
  • Unique deadline management

See the pattern?

Advanced unit-based patterns

Conditional logic per unit

This is where it gets powerful. When you design for units, conditional logic just works:

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

Each speaker process adapts to their specific needs. No manual checking required.

Parallel processing advantages

Picture this: you’re running 20 employee onboarding processes simultaneously.

  • HR handles all background checks in batch
  • IT provisions equipment based on start dates
  • Managers review their specific new hires
  • No waiting for “the slow one”

Everyone moves at their own pace.

Metrics and insights

Unit-based design gives you real analytics:

  • Average time to onboard one employee: 5 days
  • Bottleneck: IT equipment task takes 2 days
  • Success rate: 95% complete within deadline2

Compare that to bulk processes - they only show: “Monthly onboarding completed or not.” Not very helpful.

When bulk operations make sense

Don’t get me wrong - some tasks within a unit process can absolutely be bulk:

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

These work because they’re:

  • Single tasks within unit-based processes
  • Reporting or communication activities
  • End-of-period administrative work

The difference? Nobody’s waiting on these to continue their work.

Converting existing bulk processes

Assessment questions

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 affect others unnecessarily?
  4. Would parallel processing improve efficiency?

Got a “yes” to any of these? Time to convert to unit-based design.

Migration approach

Here’s your roadmap:

  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. Use bulk launch for multiple instances
  6. Track improvements in clarity and speed

Most teams see results within the first week.

Tips for effective unit-based templates

1. Use variables for customization

  • {{Employee Name}}
  • {{Invoice Number}}
  • {{Customer Company}}

This makes each instance clearly identifiable. No more guessing which process is which.

2. Design for the majority case

Build for the 80% standard case, then use conditions for exceptions. Don’t overcomplicate.

Use task comments to reference related processes:

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

It’s like leaving breadcrumbs for yourself (and your team).

4. Enable bulk actions where appropriate

Here’s the beauty - while processes are unit-based, you can still:

  • Launch multiple instances at once
  • Run reports across all instances
  • Bulk update template for all future instances

Best of both worlds.

Key takeaway

Think in units, benefit in multiples. Design your templates for one perfect instance - then run as many as needed with complete visibility and control.

This shift from bulk to unit thinking? It transforms chaotic group activities into manageable, trackable, improvable workflows. Your team will thank you.

Documenting > Templates

Templates are reusable blueprints that transform business processes into self-driving workflows by capturing every step and decision point while automatically assigning tasks sending reminders and tracking progress to eliminate process variations and reduce completion time by 40%.

Miscellaneous > Tallyfy vs. Projects

Tallyfy specializes in managing predictable repeatable workflows while project management software focuses on tracking unique one-time projects with Tallyfy eliminating chaos through standardization rather than organizing it.

Tracking And Tasks > An overview of processes

A process in Tallyfy is a running instance of a template that transforms your workflow blueprint into actual trackable work with unique naming audit trails and the ability to add one-off tasks while maintaining independence from template updates.

Templates > Templates vs. processes

Tallyfy’s master templates serve as single sources of truth that generate customized process instances while maintaining version independence and enabling continuous improvement through feedback loops.

Footnotes

  1. Launch multiple process instances simultaneously using CSV import or API batch operations ↩

  2. Tallyfy Analytics provides data on completion rates, cycle times, and bottlenecks for analysis in your BI tools ↩

Get in touch
About Tallyfy